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 |
|---|---|---|---|---|---|
badlands-model/BayesLands | pyBadlands/simulation/buildFlux.py | 1 | 13637 | ##~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~##
## ##
## This file forms part of the Badlands surface processes modelling application. ##
## ##
## For full license and copyright information, please refer to the LICENSE.md file ##
## located at the project root, or contact the authors. ##
## ##
##~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~#~##
"""
This file is the main entry point to compute flow network and associated sedimentary fluxes.
"""
import sys
import time
import numpy as np
import mpi4py.MPI as mpi
from matplotlib import path
from pyBadlands import (elevationTIN)
def streamflow(input, FVmesh, recGrid, force, hillslope, flow, elevation, \
lGIDs, rain, tNow, verbose=False):
"""
Compute flow network.
"""
rank = mpi.COMM_WORLD.rank
size = mpi.COMM_WORLD.size
comm = mpi.COMM_WORLD
# Update sea-level
walltime = time.clock()
force.getSea(tNow)
fillH = None
# Update river input
force.getRivers(tNow)
riverrain = rain+force.rivQw
# Build an initial depression-less surface at start time if required
if input.tStart == tNow and input.nopit == 1 :
fillH = elevationTIN.pit_stack_PD(elevation,input.nopit,force.sealevel)
elevation = fillH
else:
fillH = elevationTIN.pit_stack_PD(elevation,0,force.sealevel)
if rank == 0 and verbose and input.spl:
print " - depression-less algorithm PD with stack", time.clock() - walltime
# Compute stream network
walltime = time.clock()
flow.SFD_receivers(fillH, elevation, FVmesh.neighbours,
FVmesh.vor_edges, FVmesh.edge_length,
lGIDs)
if rank == 0 and verbose:
print " - compute receivers parallel ", time.clock() - walltime
# Distribute evenly local minimas to processors on filled surface
walltime = time.clock()
flow.localbase = np.array_split(flow.base, size)[rank]
flow.ordered_node_array_filled()
if rank == 0 and verbose:
print " - compute stack order locally for filled surface", time.clock() - walltime
walltime = time.clock()
stackNbs = comm.allgather(len(flow.localstack))
globalstack = np.zeros(sum(stackNbs), dtype=flow.localstack.dtype)
comm.Allgatherv(sendbuf=[flow.localstack, mpi.INT],
recvbuf=[globalstack, (stackNbs, None), mpi.INT])
flow.stack = globalstack
if rank == 0 and verbose:
print " - send stack order for filled surface globally ", time.clock() - walltime
# Distribute evenly local minimas on real surface
walltime = time.clock()
flow.localbase1 = np.array_split(flow.base1, size)[rank]
flow.ordered_node_array_elev()
if rank == 0 and verbose:
print " - compute stack order locally for real surface", time.clock() - walltime
walltime = time.clock()
stackNbs1 = comm.allgather(len(flow.localstack1))
globalstack1 = np.zeros(sum(stackNbs1), dtype=flow.localstack1.dtype)
comm.Allgatherv(sendbuf=[flow.localstack1, mpi.INT],
recvbuf=[globalstack1, (stackNbs1, None), mpi.INT])
flow.stack1 = globalstack1
if rank == 0 and verbose:
print " - send stack order for real surface globally ", time.clock() - walltime
# Compute a unique ID for each local depression and their downstream draining nodes
flow.compute_parameters_depression(fillH,elevation,FVmesh.control_volumes,force.sealevel)
# Compute discharge
walltime = time.clock()
flow.compute_flow(elevation, FVmesh.control_volumes, riverrain)
if rank == 0 and verbose:
print " - compute discharge ", time.clock() - walltime
return fillH, elevation
def sediment_flux(input, recGrid, hillslope, FVmesh, tMesh, flow, force, rain, lGIDs, applyDisp, straTIN, \
mapero, cumdiff, cumhill, fillH, disp, inGIDs, elevation, tNow, tEnd, verbose=False):
"""
Compute sediment fluxes.
"""
rank = mpi.COMM_WORLD.rank
size = mpi.COMM_WORLD.size
comm = mpi.COMM_WORLD
flow_time = time.clock()
#verbose = True
# Get active layer
if straTIN is not None:
walltime = time.clock()
flow.activelay[flow.activelay<1.] = 1.
flow.activelay[flow.activelay>straTIN.activeh] = straTIN.activeh
straTIN.get_active_layer(flow.activelay,verbose)
activelay = straTIN.alayR
flow.straTIN = 1
# Set the average erodibility based on rock types in the active layer
flow.erodibility = np.sum(straTIN.rockCk*activelay/flow.activelay.reshape(len(elevation),1),axis=1)
eroCk = straTIN.rockCk
if rank == 0 and verbose:
print " - Get active layer ", time.clock() - walltime
else:
activelay = None
eroCk = 0.
# Find border/inside nodes
if flow.domain is None:
ids = np.arange(len(FVmesh.control_volumes))
tmp1 = np.where(FVmesh.control_volumes>0.)[0]
xyMin = [recGrid.regX.min()-1., recGrid.regY.min()-1.]
xyMax = [recGrid.regX.max()+1., recGrid.regY.max()+1.]
flow.domain = path.Path([(xyMin[0],xyMin[1]),(xyMax[0],xyMin[1]), (xyMax[0],xyMax[1]), (xyMin[0],xyMax[1])])
tmp2 = flow.domain.contains_points(flow.xycoords)
flow.insideIDs = np.intersect1d(tmp1,ids[tmp2])
flow.borders = np.zeros(len(FVmesh.control_volumes),dtype=int)
flow.borders[flow.insideIDs] = 1
flow.outsideIDs = np.where(flow.borders==0)[0]
xyMin2 = [recGrid.regX.min()+recGrid.resEdges, recGrid.regY.min()+recGrid.resEdges]
xyMax2 = [recGrid.regX.max()-recGrid.resEdges, recGrid.regY.max()-recGrid.resEdges]
xyMin2 = [recGrid.regX.min()+1, recGrid.regY.min()+1]
xyMax2 = [recGrid.regX.max()-1, recGrid.regY.max()-1]
domain = path.Path([(xyMin2[0],xyMin2[1]),(xyMax2[0],xyMin2[1]), (xyMax2[0],xyMax2[1]), (xyMin2[0],xyMax2[1])])
tmp3 = domain.contains_points(flow.xycoords)
flow.insideIDs2 = ids[tmp3]
flow.borders2 = np.zeros(len(FVmesh.control_volumes),dtype=int)
flow.borders2[flow.insideIDs2] = 1
flow.outsideIDs2 = np.where(flow.borders2==0)[0]
# Compute CFL condition
walltime = time.clock()
if input.Hillslope and hillslope.updatedt == 0:
if hillslope.Sc == 0:
hillslope.dt_stability(FVmesh.edge_length[inGIDs,:tMesh.maxNgbh])
else:
hillslope.dt_stabilityCs(elevation, FVmesh.neighbours, FVmesh.edge_length,
lGIDs, flow.borders2)
if hillslope.CFL < input.minDT:
print 'Decrease your hillslope diffusion coefficients to ensure stability.'
sys.exit(0)
hillslope.dt_stability_ms(FVmesh.edge_length[inGIDs,:tMesh.maxNgbh])
elif hillslope.CFL is None:
hillslope.CFL = tEnd-tNow
flow.dt_stability(fillH, inGIDs)
CFLtime = min(flow.CFL, hillslope.CFL)
if CFLtime>1.:
CFLtime = float(round(CFLtime-0.5,0))
if rank == 0 and verbose:
print 'CFL for hillslope and flow ',hillslope.CFL,flow.CFL,CFLtime
CFLtime = min(CFLtime, tEnd - tNow)
CFLtime = max(input.minDT, CFLtime)
CFLtime = min(input.maxDT, CFLtime)
if rank == 0 and verbose:
print " - Get CFL time step ", time.clock() - walltime
# Compute sediment fluxes
if input.erolays >= 0:
oldelev = np.copy(elevation)
# Initial cumulative elevation change
walltime = time.clock()
timestep, sedchange, erosion, deposition = flow.compute_sedflux(FVmesh.control_volumes, elevation, rain, fillH,
CFLtime, activelay, eroCk, force.rivQs, force.sealevel, input.perc_dep,
input.slp_cr, FVmesh.neighbours, verbose=False)
if rank == 0 and verbose:
print " - Get stream fluxes ", time.clock() - walltime
ed = np.sum(sedchange,axis=1)
elevation += ed
cumdiff += ed
# Compute marine sediment diffusion
if hillslope.CDriver > 0.:
walltime = time.clock()
# Initialise marine sediments diffusion array
it = 0
sumdep = np.sum(deposition,axis=1)
maxth = 0.1
diffstep = timestep
diffcoeff = hillslope.sedfluxmarine(force.sealevel, elevation, FVmesh.control_volumes)
# Perform river related sediment diffusion
while diffstep > 0. and it < 1000:
# Define maximum time step
maxstep = min(hillslope.CFLms,diffstep)
# Compute maximum marine fluxes and maximum timestep to avoid excessive diffusion erosion
diffmarine, mindt = flow.compute_marine_diffusion(elevation, sumdep, FVmesh.neighbours, FVmesh.vor_edges,
FVmesh.edge_length, diffcoeff, lGIDs, force.sealevel, maxth, maxstep)
diffmarine[flow.outsideIDs] = 0.
maxstep = min(mindt,maxstep)
# if maxstep < input.minDT:
# print 'WARNING: marine diffusion time step is smaller than minimum timestep:',maxstep
# print 'You will need to decrease your diffusion coefficient for criver'
# stop
# Update diffusion time step and total diffused thicknesses
diffstep -= maxstep
# Distribute rock based on their respective proportions in the deposited columns
if straTIN is not None:
# Compute multi-rock diffusion
sedpropflux, difftot = flow.compute_sediment_marine(elevation, deposition, sumdep,
diffcoeff*maxstep, FVmesh.neighbours, force.sealevel,
maxth, FVmesh.vor_edges, FVmesh.edge_length, lGIDs)
difftot[flow.outsideIDs] = 0.
sedpropflux[flow.outsideIDs,:] = 0.
# Update deposition for each rock type
deposition += sedpropflux
deposition[deposition<0] = 0.
# Update elevation, erosion/deposition
sumdep += difftot
elevation += difftot
cumdiff += difftot
else:
# Update elevation, erosion/deposition
sumdep += diffmarine*maxstep
elevation += diffmarine*maxstep
cumdiff += diffmarine*maxstep
it += 1
if rank == 0 and verbose:
print " - Get river sediment marine fluxes ", time.clock() - walltime
# Compute hillslope processes
dtype = 1
if straTIN is None:
dtype = 0
walltime = time.clock()
area = np.copy(FVmesh.control_volumes)
area[flow.outsideIDs2] = 0.
diffcoeff = hillslope.sedflux(force.sealevel, elevation, FVmesh.control_volumes)
diffcoeff[flow.outsideIDs2] = 0.
diff_flux = flow.compute_hillslope_diffusion(elevation, FVmesh.neighbours, FVmesh.vor_edges,
FVmesh.edge_length, lGIDs, dtype, hillslope.Sc)
diff_flux[flow.outsideIDs2] = 0.
cdiff = diffcoeff*diff_flux*timestep
if straTIN is None:
if input.btype == 'outlet':
cdiff[flow.insideIDs[0]] = 0.
# Update dataset
elevation[flow.insideIDs] += cdiff[flow.insideIDs]
cumdiff[flow.insideIDs] += cdiff[flow.insideIDs]
cumhill[flow.insideIDs] += cdiff[flow.insideIDs]
else:
straTIN.update_layers(erosion, deposition, elevation, verbose)
# Get the active layer thickness to erode using diffusion
maxlayh = -cdiff
maxlayh[maxlayh<1.] = 1.
straTIN.get_active_layer(maxlayh)
# Compute multi-rock diffusion
tdiff, erosion, deposition = flow.compute_sediment_hillslope(elevation, straTIN.alayR,
diffcoeff*timestep, FVmesh.neighbours, FVmesh.vor_edges,
maxlayh, FVmesh.edge_length, lGIDs)
if input.btype == 'outlet':
tdiff[flow.insideIDs[0],:] = 0.
# # Update dataset
elevation += tdiff
cumdiff += tdiff
cumhill += tdiff
# Update active layer
straTIN.update_layers(erosion, deposition, elevation, verbose)
if input.btype == 'slope':
elevation[:len(flow.parentIDs)] = elevation[flow.parentIDs]-0.1
elif input.btype == 'flat':
elevation[:len(flow.parentIDs)] = elevation[flow.parentIDs]
elif input.btype == 'wall':
elevation[:len(flow.parentIDs)] = elevation[flow.parentIDs]+100.
elif input.btype == 'outlet':
elevation[1:len(flow.parentIDs)] = elevation[flow.parentIDs[1:]]+100.
elif input.btype == 'wall1':
elevation[:len(flow.parentIDs)] = elevation[flow.parentIDs]-0.1
elevation[:recGrid.nx+1] = elevation[flow.parentIDs[:recGrid.nx+1]]+100.
if rank == 0 and verbose:
print " - Get hillslope fluxes ", time.clock() - walltime
# Update erodibility values
if input.erolays >= 0:
mapero.getErodibility(elevation-oldelev)
flow.erodibility = mapero.erodibility
if applyDisp:
elevation += disp * timestep
tNow += timestep
if rank == 0 and verbose:
print " - Flow computation ", time.clock() - flow_time
return tNow,elevation,cumdiff,cumhill
| gpl-3.0 |
numenta/NAB | nab/detectors/random_cut_forest/random_cut_forest.py | 1 | 16737 | #! /usr/bin/env python
# ----------------------------------------------------------------------
# Copyright (C) 2018, Numenta, Inc. Unless you have an agreement
# with Numenta, Inc., for a separate 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/
# ----------------------------------------------------------------------
"""
Use this script to evaluate [Robust Random Cut Forest Based Anomaly Detection On
Streams][4] algorithm on NAB.
This script will create an [AWS Kinesis Analytics][2] application that
will use the [RANDOM_CUT_FOREST][3] function to detect anomalies on NAB data
files as they are streamed via AWS API ("boto3"). The application's output
stream with the anomaly scores will be stored in the "results" folder for
further processing using NAB standard tools ("run.py") to optimize, normalize
and score the results.
See [NAB Entry Points][1] "Option 2" for more information.
The following commands were used calculate NAB scores using this script:
```
# Create results folders
python scripts/create_new_detector.py --detector randomCutForest
# Create kinesis application
python nab/detectors/random_cut_forest/random_cut_forest.py --create
# Stream all NAB data
python nab/detectors/random_cut_forest/random_cut_forest.py --stream
# Clean up
python nab/detectors/random_cut_forest/random_cut_forest.py --delete
# Compute NAB scores
python run.py -d randomCutForest --optimize --score --normalize
```
[1]: https://github.com/numenta/NAB/wiki/NAB-Entry-Points
[2]: https://aws.amazon.com/kinesis/data-analytics/
[3]: https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-random-cut-forest.html
[4]: http://proceedings.mlr.press/v48/guha16.pdf
"""
import os
import sys
import time
import argparse
import boto3
import pandas
from nab.corpus import Corpus
from nab.labeler import CorpusLabel
SCRIPT_PATH = os.path.abspath(os.path.dirname(__file__))
DATA_PATH = os.path.normpath(os.path.join(SCRIPT_PATH, os.path.pardir,
os.path.pardir, os.path.pardir,
"data"))
RESULTS_PATH = os.path.normpath(os.path.join(SCRIPT_PATH, os.path.pardir,
os.path.pardir, os.path.pardir,
"results"))
LABELS_FILE = os.path.normpath(os.path.join(SCRIPT_PATH, os.path.pardir,
os.path.pardir, os.path.pardir,
"labels", "combined_windows.json"))
APPLICATION_SOURCE_FILE = os.path.join(SCRIPT_PATH, "random_cut_forest.sql")
ROLE_TRUST_POLICY_FILE = os.path.join(SCRIPT_PATH, "role_trust_policy.json")
ROLE_PERMISSION_POLICY_FILE = os.path.join(SCRIPT_PATH,
"role_permission_policy.json")
DETECTOR_NAME = "randomCutForest"
APPLICATION_NAME = "nab_rcf"
OUTPUT_STREAM_NAME = "nab_output"
INPUT_STREAM_NAME = "nab_input"
# Configure kinesis analytics application input stream schema. This schema
# should match the SQL stream definition. See "random_cut_forest.sql"
INPUT_SCHEMA = {
"RecordColumns": [{
"Name": "COL_TIMESTAMP",
"SqlType": "TIMESTAMP"
}, {
"Name": "COL_VALUE",
"SqlType": "DOUBLE"
}],
"RecordFormat": {
"MappingParameters": {
"CSVMappingParameters": {
"RecordColumnDelimiter": ",",
"RecordRowDelimiter": "\n"
}
},
"RecordFormatType": "CSV"
}
}
def createStreams():
"""
Creates AWS Kinesis input and output streams
:return: dictionary with the newly created stream ARNs
"""
kinesis = boto3.client("kinesis")
result = {}
streams = [INPUT_STREAM_NAME, OUTPUT_STREAM_NAME]
for name in streams:
kinesis.create_stream(StreamName=name, ShardCount=1)
# Wait until all streams are created
waiter = kinesis.get_waiter('stream_exists')
for name in streams:
waiter.wait(StreamName=name)
response = kinesis.describe_stream(StreamName=name)
result[name] = response["StreamDescription"]["StreamARN"]
return result
def deleteStreams():
"""
Deletes AWS Kinesis streams created by "createStreams"
"""
kinesis = boto3.client("kinesis")
streams = [INPUT_STREAM_NAME, OUTPUT_STREAM_NAME]
for name in streams:
try:
kinesis.delete_stream(StreamName=name)
except kinesis.exceptions.ResourceNotFoundException:
pass
# Wait until all streams are deleted
waiter = kinesis.get_waiter('stream_not_exists')
for name in streams:
waiter.wait(StreamName=name)
def createRole(inputStream, outputStream):
"""
Creates a new AWS IAM Role with access to the input and output AWS Kinesis
streams created by "createStreams".
See "role_permission_policy.json" and "role_trust_policy.json"
:param inputStream: Kinesis input stream ARN
:param outputStream: Kinesis output stream ARN
:return: The Role ARN
"""
iam = boto3.client("iam")
roleName = "kinesis-analytics-service-{0}-role".format(APPLICATION_NAME)
# Create new rolte and give it access to the input and output streams
trustPolicy = open(ROLE_TRUST_POLICY_FILE, "r").read()
response = iam.create_role(Path="/nab/", RoleName=roleName,
AssumeRolePolicyDocument=trustPolicy)
role = response["Role"]
permissionPolicy = open(ROLE_PERMISSION_POLICY_FILE, "r").read()
policyName = "kinesis-analytics-service-{0}-policy".format(APPLICATION_NAME)
iam.put_role_policy(RoleName=roleName, PolicyName=policyName,
PolicyDocument=permissionPolicy % {
"inputStream": inputStream,
"outputStream": outputStream})
# FIXME: Wait until IAM role policy update is propagated
time.sleep(20)
return role['Arn']
def deleteRole():
"""
Deletes the role created via "createRole" for the given application
"""
iam = boto3.client("iam")
roleName = "kinesis-analytics-service-{0}-role".format(APPLICATION_NAME)
policyName = "kinesis-analytics-service-{0}-policy".format(APPLICATION_NAME)
try:
iam.delete_role_policy(RoleName=roleName, PolicyName=policyName)
except iam.exceptions.NoSuchEntityException:
pass
try:
iam.delete_role(RoleName=roleName)
except iam.exceptions.NoSuchEntityException:
pass
def createApplication():
"""
Create a new AWS Kinesis Analytics Application used to provide anomaly
scores from NAB data files. See "random_cut_forest.sql"
"""
print("Creating kinesis streams")
streams = createStreams()
inputStream = streams[INPUT_STREAM_NAME]
outputStream = streams[OUTPUT_STREAM_NAME]
print("Creating IAM Role")
role = createRole(inputStream, outputStream)
print("Creating kinesis analytics application")
sourceCode = open(APPLICATION_SOURCE_FILE, "r").read()
kinesisAnalytics = boto3.client("kinesisanalytics")
kinesisAnalytics.create_application(
ApplicationName=APPLICATION_NAME,
ApplicationCode=sourceCode,
Inputs=[{
"NamePrefix": "SOURCE_SQL_STREAM",
"InputSchema": INPUT_SCHEMA,
"KinesisStreamsInput": {
"ResourceARN": inputStream,
"RoleARN": role
}
}],
Outputs=[{
"Name": "DESTINATION_SQL_STREAM",
"DestinationSchema": {
"RecordFormatType": "CSV"
},
"KinesisStreamsOutput": {
"ResourceARN": outputStream,
"RoleARN": role
}
}])
def startApplication():
"""
Starts the application created via "createApplication"
"""
kinesisAnalytics = boto3.client("kinesisanalytics")
response = kinesisAnalytics.describe_application(
ApplicationName=APPLICATION_NAME)
application = response["ApplicationDetail"]
inputId = application['InputDescriptions'][0]['InputId']
kinesisAnalytics.start_application(ApplicationName=APPLICATION_NAME,
InputConfigurations=[{
"Id": inputId,
"InputStartingPositionConfiguration": {
"InputStartingPosition": "NOW"
}
}])
# Wait until application starts running
response = kinesisAnalytics.describe_application(
ApplicationName=APPLICATION_NAME)
status = response["ApplicationDetail"]["ApplicationStatus"]
sys.stdout.write('Starting ')
while status != "RUNNING":
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
response = kinesisAnalytics.describe_application(
ApplicationName=APPLICATION_NAME)
status = response["ApplicationDetail"]["ApplicationStatus"]
sys.stdout.write(os.linesep)
def stopApplication():
"""
Stops the application created via "createApplication"
"""
kinesisAnalytics = boto3.client("kinesisanalytics")
kinesisAnalytics.stop_application(ApplicationName=APPLICATION_NAME)
# Wait until application stops running
response = kinesisAnalytics.describe_application(
ApplicationName=APPLICATION_NAME)
status = response["ApplicationDetail"]["ApplicationStatus"]
sys.stdout.write('Stopping ')
while status != "READY":
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(1)
response = kinesisAnalytics.describe_application(
ApplicationName=APPLICATION_NAME)
status = response["ApplicationDetail"]["ApplicationStatus"]
sys.stdout.write(os.linesep)
def deleteApplication():
"""
Deletes the application created via "createApplication"
"""
print("Deleting IAM Role")
deleteRole()
print("Deleting kinesis streams")
deleteStreams()
print("Deleting kinesis analytics application")
kinesisAnalytics = boto3.client("kinesisanalytics")
try:
response = kinesisAnalytics.describe_application(
ApplicationName=APPLICATION_NAME)
kinesisAnalytics.delete_application(
ApplicationName=response["ApplicationDetail"]["ApplicationName"],
CreateTimestamp=response["ApplicationDetail"]["CreateTimestamp"])
except kinesisAnalytics.exceptions.ResourceNotFoundException:
pass
def streamFile(corpus, corpusLabel, resultsdir, name):
"""
Streams a single NAB data file to Kinesis Analytics Application saving the
results for further processing by NAB tools
:param corpus: NAB corpus created via "corpus = Corpus(datadir)"
:param corpusLabel: NAB corpus labels
:param resultsdir: Path to store the results. Make sure to run
'scripts/create_new_detector.py --detector randomCutForest'
first
:param name: NAB data file name (i.e. "realKnownCause/nyc_taxi.csv")
:return: The result file absolute path
"""
print("Streaming", name)
startApplication()
# Get latest position from the output stream before streaming new records
kinesis = boto3.client("kinesis")
response = kinesis.describe_stream(StreamName=OUTPUT_STREAM_NAME)
shardId = response["StreamDescription"]["Shards"][0]["ShardId"]
response = kinesis.get_shard_iterator(StreamName=OUTPUT_STREAM_NAME,
ShardId=shardId,
ShardIteratorType="LATEST")
shardIterator = response["ShardIterator"]
# Send NAB data as a single CSV file to the input stream
datafile = corpus.dataFiles[name]
total = datafile.data.shape[0]
kinesis.put_record(StreamName=INPUT_STREAM_NAME,
PartitionKey=name,
Data=datafile.data.to_csv(header=False, index=False))
# Make sure to read all records from output stream
rows = []
sys.stdout.write("\rProcessed 0/{} ".format(total))
sys.stdout.flush()
while len(rows) < total:
response = kinesis.get_records(ShardIterator=shardIterator)
records = response["Records"]
if len(records) > 0:
parsed_records = []
for rec in records:
parsed_record = str(rec["Data"], "utf-8")
parsed_record = parsed_record.strip('\n')
parsed_record = parsed_record.split(",")
parsed_records.append(parsed_record)
rows.extend(parsed_records)
shardIterator = response["NextShardIterator"]
sys.stdout.write("\rProcessed {}/{} ".format(len(rows), total))
sys.stdout.flush()
else:
# Back off until the application starts streaming the anomalies
sys.stdout.write(".")
sys.stdout.flush()
time.sleep(1)
sys.stdout.write(os.linesep)
# Streaming results may arrive out of order
rows.sort()
results = pandas.DataFrame(rows, columns=["timestamp", "value",
"anomaly_score"])
# Add NAB corpus labels
results["label"] = corpusLabel.labels[name]["label"]
# Save results
relativeDir, fileName = os.path.split(name)
resultFile = os.path.join(resultsdir, DETECTOR_NAME, relativeDir,
"{}_{}".format(DETECTOR_NAME, fileName))
results.to_csv(resultFile, index=False)
# Stop application after every data file to reset the algorithm
stopApplication()
return resultFile
def streamAll(corpus, corpusLabel, resultsdir):
"""
Streams all files in the NAB corpus
:param corpus: NAB corpus created via "corpus = Corpus(dataDir)"
:param corpusLabel: NAB corpus labels
:param resultsdir: Path to store the results. Make sure to run
'scripts/create_new_detector.py --detector randomCutForest'
first
"""
for name in list(corpus.dataFiles.keys()):
streamFile(corpus, corpusLabel, resultsdir, name)
def main(args):
if args.create:
createApplication()
if args.start:
startApplication()
if args.stop:
stopApplication()
if args.file:
corpus = Corpus(args.data)
labels = CorpusLabel(path=args.labels, corpus=corpus)
streamFile(corpus, labels, args.results, args.file)
if args.stream:
corpus = Corpus(args.data)
labels = CorpusLabel(path=args.labels, corpus=corpus)
streamAll(corpus, labels, args.results)
if args.delete:
deleteApplication()
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Use this script to evaluate 'Robust Random Cut Forest Based "
"Anomaly Detection On Streams' algorithm on NAB.",
epilog="Make sure to run 'scripts/create_new_detector.py --detector "
"randomCutForest' before using this script. See README.md for "
"details",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--data",
default=DATA_PATH,
help="Path to NAB data files.")
parser.add_argument("--labels",
default=LABELS_FILE,
help="JSON file containing ground truth labels for the "
"corpus.")
parser.add_argument("--results",
default=RESULTS_PATH,
help="Path to NAB results path.")
parser.add_argument("--create", "-c",
help="Create AWS Kinesis application",
default=False,
action="store_true")
parser.add_argument("--delete", "-d",
help="Delete AWS Kinesis application",
default=False,
action="store_true")
parser.add_argument("--start",
help="Start AWS Kinesis application",
default=False,
action="store_true")
parser.add_argument("--stop",
help="Stop AWS Kinesis application",
default=False,
action="store_true")
parser.add_argument("--stream", "-s",
default=False,
help="Stream all NAB data files to AWS Kinesis "
"application",
action="store_true")
parser.add_argument("--file", "-f",
help="Stream a single NAB data file name to AWS Kinesis "
"application")
args = parser.parse_args()
if args.create or args.start or args.file or args.stream or args.stop \
or args.delete:
main(args)
else:
parser.print_help()
| agpl-3.0 |
scizen9/kpy | SEDM/GUIhandle.py | 2 | 20745 | '''
SegmentationMap class wraps around several functions in SEDM package and
provides a convenient way to handle SEDM data.
'''
import NPK.Atmosphere as Atm
import NPK.PlotHelp as PH
import datetime
import numpy as np
import json
import os
import pyfits
import scipy.io
import matplotlib.pyplot as pl
from matplotlib.backend_bases import KeyEvent
from matplotlib.backend_bases import PickEvent
from scipy.interpolate import interp1d
import Disp
import SegMap
reload(SegMap)
from SegMap import SegmentationMap
import Extract
from NPK.Standards import Standards
reload(Extract)
reload(Disp)
def clean_header(header):
todel = ['SIMPLE', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2',
'NAXIS0', 'EXTEND', 'BZERO', 'BSCALE']
for d in todel:
try: del header[d]
except: pass
return header
def merge_headers(headers):
h = headers[0]
i = 1
for new in headers[1:]:
for key in new.keys():
if 'NAXIS' in key: continue
if key in h:
if h[key] != new[key]:
try: h[key + "_%2.2i" % i] = new[key]
except: pass
else:
try: h[key + "_%2.2i" % i] = new[key]
except: pass
return h
class PositionPicker(object):
'''Shows the IFU field and allows the user to select an object.
Takes:
A plan list that is composed of dictionary that includes:
infiles [N_spec]: String of paths to .mat files
name: String of object name
Optional:
outdir: path to write the results to, otherwise defaults to
oudri/[name]/[obsdate]/version#/....
shifts [N_spec]: Float of pixels to shift spectrum for flexure
'''
index = 0 # index into the file list
spx_ix = 0 # index into spectrum list
plan = None
subtract_sky = False
picked = None # Spectrum position pixed in IFU coordinates
olines = [372.7, 486.1, 500.7, 656.3]
tlines = [761.5, 589.0, 557.7, 435.8, 519.9, 630.0]
positions=None
qecurve = None
output_head = "/scr2/npk/sedm/reduced/"
show_calib = True
norm = None
def __init__(self,plan,positions=('OnSkyX','OnSkyY'),
qefunction=None, stdpaths=None, normpath=None):
print "Starting picker GUI"
self.plan = plan
self.positions=positions
self.stdpaths = stdpaths
self.load_stds()
if normpath is not None:
self.norm = np.load(normpath)
self.norm[self.norm < .5] = np.nan
self.norm[self.norm > 2] = np.nan
self.fig = pl.figure(1)
self.fig.canvas.mpl_connect("key_press_event", self)
self.fig.canvas.mpl_connect("pick_event", self)
self.fig.canvas.mpl_connect("button_press_event", self)
self.fig2 = pl.figure(2,figsize=(16,4.5))
self.fig2.canvas.mpl_connect("key_press_event", self)
self.fig2.canvas.mpl_connect("pick_event", self)
self.fig3 = pl.figure(3, figsize=(12,4))
self.fig3.canvas.mpl_connect("key_press_event", self)
self.fig3.canvas.mpl_connect("pick_event", self)
self.fig4 = pl.figure(4, figsize=(8,2.25))
self.fig4.canvas.mpl_connect("key_press_event", self)
self.fig4.canvas.mpl_connect("pick_event", self)
if qefunction is not None:
self.qecurve = qefunction
self.index = 0
self.check_plan()
self.load()
self.draw()
def check_plan(self):
'''Checks the plan to see if it makes sense and the files load'''
for el in self.plan:
print el['name']
for fname in el['infiles']:
if not os.path.exists(fname):
raise Exception("%s: file does not exist" % fname)
if 'object_diam' in el:
if (0 > el['object_diam'] < 300):
raise Exception("%s: not appropriate object diam" %
el['object_diam'])
if 'sky_annulus' in el:
if len(el['sky_annulus']) != 2:
raise Exception("%s: not appropriate sky annulus" %
el["sky_annulus"])
def dump(self):
"""Write status to file"""
plan = self.plan[self.index]
dt = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
if self.status == 'standard':
outfile = os.path.join(self.outdir,
"STD-%s.json" % plan['name'])
else:
outfile = os.path.join(self.outdir,
"%s.json" % plan['name'])
print "Writing to: %s" % outfile
str = json.dumps({"outfile": outfile,
"infiles": plan['infiles'],
"object_diam": plan['object_diam'],
"sky_annulus": plan['sky_annulus'],
"status": self.status,
"picked": self.picked,
"pixel_shift": self.pixel_shift,
"when": dt}, indent=4)
try:
f=open(outfile, "w")
f.write(str)
f.close()
except Exception as e:
raise("Could not write %s: %s" % (outfile, e))
outfile = os.path.join(self.outdir,
"%s_all" % plan['name'])
np.savez(outfile, self.all_obj_spec)
outfile = os.path.join(self.outdir,
"%s_sky" % plan['name'])
np.savez(outfile, self.all_sky_spec)
result = np.array([self.sky_spec[0], self.sky_spec[1],
self.obj_spec[1]-self.sky_spec[1]])
self.RESULTS[self.spx_ix] = result
header = merge_headers(self.headers)
pf = pyfits.PrimaryHDU(result,header=header)
name = self.plan[self.index]['name']
pf.header["OBJECT"] = name
pf.header["SPEC"] = self.plan[self.index]['infiles'][self.spx_ix]
outpath = os.path.join(self.outdir, "%s_%i.fits" % (name,
self.spx_ix))
try: os.remove(outpath)
except: pass
pf.writeto(outpath)
self.draw_res()
def draw_res(self):
''' Draw the resulting spectrum'''
pl.figure(3)
pl.clf()
pl.xlim([350, 950])
pl.ylim(-1000,4000)
allwav = allsky = allobj = None
headers = []
for i in xrange(len(self.RESULTS)):
res = self.RESULTS[i]
if res is None: continue
header = self.headers[i]
header = clean_header(header)
headers.append(header)
airmass = header['airmass']
wave, sky, obj = res.copy()
skyf = interp1d(wave,sky,fill_value=np.nan,bounds_error=False)
objf = interp1d(wave,obj,fill_value=np.nan,bounds_error=False)
if self.qecurve is None: correction = 1.0
else:
print "Applying correction"
ext = 10**(-Atm.ext(wave*10)*airmass/2.5)
correction = 1/self.qecurve(wave*10)*ext
correction=1.
pl.step(wave,obj*correction)
if allwav is None:
allwav=wave[:]
allsky=sky[:]
allobj=obj[:]
else:
allsky += skyf(allwav)
allobj += objf(allwav)
if self.qecurve is None: correction = 1.0
else: correction = 1/self.qecurve(allwav*10)
pl.step(allwav, allobj*correction, linewidth=3)
#pl.step(allwav, allobj, linewidth=3)
# Raw data
result = np.array([allwav, allsky, allobj])
pf = pyfits.PrimaryHDU(result, header=header)
name = self.plan[self.index]['name']
pf.header["REDNAME"] = name
outpath = os.path.join(self.outdir, "%s.fits" % (name))
try: os.remove(outpath)
except: pass
pf.writeto(outpath)
# Corrected
if self.qecurve is not None:
result = np.array([allwav, allsky*correction, allobj*correction])
pf = pyfits.PrimaryHDU(result, header=header)
name = self.plan[self.index]['name']
pf.header["REDNAME"] = name
outpath = os.path.join(self.outdir, "%s_corr.fits" % (name))
try: os.remove(outpath)
except: pass
pf.writeto(outpath)
def load(self):
"""Load the Segmentation map"""
self.spx_ix = 0
pl.figure(1)
pl.clf()
if self.index < 0: self.index =0
if self.index >= len(self.plan):
self.index = len(self.plan)-1
print "REACHED THE END"
cur_plan = self.plan[self.index]
nfiles = len(cur_plan['infiles'])
self.SM = []
self.headers = []
for i in xrange(nfiles):
self.SM.append(SegmentationMap(cur_plan['infiles'][i],
positions=self.positions, norm=self.norm))
fits = cur_plan['infiles'][i].replace("shrunk_","").rstrip('_SI.mat')
FF = pyfits.open(fits)
self.headers.append(FF[0].header)
self.status = ["unknown"] * len(self.SM)
self.picked = [None] * len(self.SM)
self.pixel_shift = [0.0] * len(self.SM)
self.RESULTS = [None] * len(self.SM)
fn = cur_plan['infiles'][0]
fname = fn.split("/")[-1]
print fname
if "shrunk" in fname: fname = fname.replace("shrunk","")
if "_crr" in fname: fname = fname.replace("_crr","")
if "_s" in fname: fname = fname.replace("_s","")
if "_b" in fname: fname = fname.replace("_b","")
if "b_" in fname: fname = fname.replace("b_","")
if "ifu" in fname: fname = fname.replace("_ifu","")
fname = fname.rstrip(".fits_SI.mat")
print fname
fn = fname
y,mon,d = (fn[0:4], fn[4:6], fn[6:8])
h,min,s = (fn[9:11], fn[12:14], fn[15:17])
month = ["none","jan", "feb", "mar", "apr", "may", "jun", "jul", "aug",
"sep", "oct", "nov", "dec"][int(mon)]
outprefix = os.path.join(self.output_head,
cur_plan['name'],
'%s_%s_%s_%s_%s_%s' % (y, month, d, h, min, s))
try:
os.makedirs(outprefix)
except:
pass
for i in xrange(99):
outdir = os.path.join(outprefix, "v%2.2i" % i)
if not os.path.exists(outdir):
break
if len(os.listdir(outdir)) == 0:
break
if not os.path.exists(outdir):
os.makedirs(outdir)
self.outdir = outdir
print ("Loaded. Outdir: %s" % (self.outdir))
def create_spectrum(self):
plan = self.plan[self.index]
if self.picked[self.spx_ix] is None: return
self.SM[self.spx_ix].pixel_shift = self.pixel_shift[self.spx_ix]
X,Y = self.picked[self.spx_ix]
header = self.headers[self.spx_ix]
header = clean_header(header)
exptime = header['exptime']
if "object_diam" in plan: D = plan['object_diam']
else:
D = 2
plan['object_diam'] = D
header['extdiam'] = (D, 'Extraction diameter')
if "sky_annulus" in plan: s1,s2 = plan['sky_annulus']
else:
s1,s2 = 4,6
plan['sky_annulus'] = [s1,s2]
header['sky1'] = (s1, 'Sky inner annulus diameter')
header['sky2'] = (s2, 'Sky outer annulus diameter')
header['ext_pos'] = ("%s,%s" % (X,Y), 'Extraction position')
print "Extracting at: %s,%s: diam %s, sky %s/%s" % (X,Y,D,s1,s2)
sky_spec, all_sky_spec = self.SM[self.spx_ix].spectrum_in_annulus(
X,Y,small=s1,
large=s2)
wave = sky_spec["wave_nm"]
obj_spec, all_obj_spec = self.SM[self.spx_ix].spectrum_near_position(X,Y,
distance=D, onto=wave)
sky = [wave, sky_spec["spec_adu"]/len(all_sky_spec)/exptime*len(all_obj_spec)]
object = [wave, obj_spec["spec_adu"]/exptime]
self.sky_spec = sky
self.obj_spec = object
self.all_sky_spec = all_sky_spec
self.all_obj_spec = all_obj_spec
def draw_spectrum(self):
''' Draw the spectrum in figure(2)
'''
pl.figure(2)
pl.clf()
pl.xlim(350,920)
if self.picked[self.spx_ix] is None:
return
pl.xlabel("wavelength [nm]")
obj_spec = self.obj_spec[:]
sky_spec = self.sky_spec[:]
wave = obj_spec[0]
pl.step(obj_spec[0], obj_spec[1], linewidth=1)
pl.step(sky_spec[0], sky_spec[1], linewidth=1)
pl.step(sky_spec[0], obj_spec[1]-sky_spec[1], linewidth=2)
obj_spec[1] -= sky_spec[1]
correction = 1.0
if self.qecurve is not None:
correction = 1/self.qecurve(wave*10)
correction /= np.median(correction)
bad = (wave < 400) | (wave > 920) | (correction < 0)
correction[bad] =np.nan
if self.show_calib:
pl.step(wave, obj_spec[1]*correction)
pl.step(wave, sky_spec[1]*correction)
PH.transparent_legend(['o', 's', 'o-s', 'c x (o-s)', 'c x s'])
pl.xlim(350,920)
for line in self.olines:
pl.axvline(line)
for line in self.tlines:
pl.axvline(line, color='r')
def handle_shift(self, xdata, ydata):
if (xdata < 360) or (xdata > 1000): return
lines = np.concatenate((self.olines, self.tlines))
delts = (lines - xdata)
ix = np.argmin(np.abs(delts))
print "Closest to %f" % lines[ix]
line = lines[ix]
delt = delts[ix]
wave = self.sky_spec[0]
wix = np.nanargmin(np.abs(wave-line))
dw = wave[wix]-wave[wix-1]
print "Delt: {0}, dw: {1}".format(delt, dw)
self.pixel_shift[self.spx_ix] += delt/dw
print "pixel shift is: {0}".format(self.pixel_shift[self.spx_ix])
self.draw_spectrum()
def __call__(self, event):
'''Event call handler for Picker gui.'''
if event.name == 'button_press_event':
print event.xdata, event.ydata
self.picked[self.spx_ix] = (event.xdata, event.ydata)
self.create_spectrum()
self.draw_spectrum()
self.draw_selection_circle()
elif event.name == 'key_press_event':
if event.key == '\\':
print "Shifting"
self.handle_shift(event.xdata, event.ydata)
if event.key == '.':
self.next_spec()
if event.key == ',':
self.spx_ix -= 1
if self.spx_ix < 0:
self.spx_ix = 0
else:
self.draw()
self.draw_spectrum()
if event.key == 'c':
print "toggle show calib"
self.show_calib = not self.show_calib
self.draw_spectrum()
if event.key == 'n':
print "next"
self.index += 1
self.load()
self.draw()
if event.key == 'p':
print "prev"
self.index -= 1
self.load()
self.draw()
if event.key == '-':
self.subtract_sky = not self.subtract_sky
print "Substract sky: %s" % self.subtract_sky
self.draw()
if event.key == "u":
self.status[self.spx_ix] = "unsure"
self.dump()
self.draw()
if event.key == "b":
self.status[self.spx_ix] = "bad"
self.dump()
self.draw()
if event.key == "o":
self.status[self.spx_ix] = "ok"
self.dump()
self.next_spec()
if event.key == "s":
self.status[self.spx_ix] = "standard"
self.dump()
self.next_spec()
if event.key == 'h':
print """Help---
n - next
p - prev
- - subtract sky
u - unsure: there are targets visible, not sure which is correct.
b - bad: nothing visible
o - ok: target visible
"""
print event.key
def draw(self):
if self.subtract_sky:
sky = self.SM[self.spx_ix].sky_median()
sky_spec = sky['wave_nm'], sky['spec_adu']
else:
sky_spec = None
x,y,v = Extract.segmap_to_img(self.SM[self.spx_ix].SegMap,
sky_spec=sky_spec,
minl=500, maxl=700,positions=self.positions)
self.Xs = x
self.Ys = y
self.Values = v
self.draw_selection_circle()
def load_stds(self):
if self.stdpaths is None:
return
STDS = []
for stdpath in self.stdpaths:
try:
print stdpath
FF = pyfits.open(stdpath)
except:
print "Ignoring %s" % stdpath
continue
name = FF[0].header['OBJECT']
pl.figure(4)
pl.clf()
for std in Standards.keys():
if name.lower() in std.lower():
print name, std
ang = Standards[std][:,0]
stdflux = Standards[std][:,1] * 1e-16 # to erg/s/cm2/A
stdf = interp1d(ang, stdflux, bounds_error = False)
# stdf in ADU
obsl, obss, obsf = FF[0].data[0,:], FF[0].data[1,:], FF[0].data[2,:]
exptime = FF[0].header['EXPTIME']
std = (obsf - obss)/exptime
print "Std exptime: %s" % exptime
to_fit = std/stdf(obsl*10)
zero = (obsl> 990)
to_fit /= np.median(to_fit)
to_fit[zero] = 0.0
ok = (np.isfinite(to_fit)) & (obsl<1100) & (obsl>350)
poly= np.polyfit(obsl[ok]*10, to_fit[ok], 25)
qef = np.poly1d(poly)
print poly
pl.xlim([350, 950])
pl.plot(obsl[ok], to_fit[ok],'.')
pl.plot(obsl[ok], qef(obsl[ok]*10))
pl.xlim([350, 950])
def qe_clean_functor(qef):
def to_return(lam):
v = qef(lam)
v[lam<3750] = np.nan
v[lam>9500] = np.nan
return v
return to_return
self.qecurve = qe_clean_functor(qef)
def draw_selection_circle(self):
pl.figure(1, figsize=(9,8))
pl.ion()
pl.clf()
name = self.plan[self.index]['name']
if self.positions[0] == 'OnSkyX': diam = 0.5
else: diam = 1
pl.title("{0}:{1}. {2} of {3}".format(name,
self.status[self.spx_ix],
self.spx_ix,
len(self.SM)-1))
if self.subtract_sky:
vals = self.Values[:]
cut=25
vals[vals<-cut/4] = -cut/4
vals[vals>cut] = cut
else: vals = self.Values
v = vals[:]
#v[v<-100] = -100
#v[v>50000] = 50000
pl.scatter(self.Xs,
self.Ys,
c=vals,
s=40,
picker=diam,
marker='h')
pl.xlim(-100,2048+100)
pl.ylim(-100,2048+100)
pl.colorbar()
if self.picked[self.spx_ix] is not None:
X,Y = self.picked[self.spx_ix]
s1,s2 = self.plan[self.index]['sky_annulus']
print("Adding circle at {0}/{1}".format(X,Y))
obj_radius = self.plan[self.index]['object_diam']/2.0
obj_circle = pl.Circle((X,Y), radius=obj_radius, fill=False,
color='black',linewidth=2)
s1_circle = pl.Circle((X,Y), radius=s1/2.0, fill=False,
color='black',linewidth=2)
s2_circle = pl.Circle((X,Y), radius=s2/2.0, fill=False,
color='black',linewidth=2)
fig = pl.figure(1)
ax = fig.add_subplot(1,1,1)
ax.add_patch(obj_circle)
ax.add_patch(s1_circle)
ax.add_patch(s2_circle)
def next_spec(self):
self.spx_ix += 1
max_spx_ix = len(self.SM)
if self.spx_ix >= max_spx_ix:
self.spx_ix = max_spx_ix-1
else:
self.draw()
self.draw_spectrum()
self.draw_selection_circle()
| gpl-2.0 |
bmroach/Audio_Effects_Suite | Working-Directory/Flanger/mainFlanger.py | 2 | 2083 | """
Filename: mainFlanger.py
See README.md
Developed under the Apache License 2.0
"""
#______________________________________________________________________________
#Header Imports
import array
import contextlib
import wave
import matplotlib.pyplot as plt
import numpy as np
import math
import copy
import sys
sys.path.append('../Utilities')
import utilities as ut
import vocoder as vo
#______________________________________________________________________________
#Start mainFlanger.py
# Global parameters
dirIn = "../../Original-Audio-Samples/"
dirOut = "../../Output-Audio-Samples/Flanger/"
numChannels = 1 # mono
sampleWidth = 2 # in bytes, a 16-bit short
sampleRate = 44100
mulFactor = sampleRate * 10
#______________________________________________________________________________
def flanger(signal, delay=20):
"""delay in milliseconds"""
delaySamples = int(44.1*delay)
length = len(signal)
signal1 = [x*.5 for x in signal]
signal2 = copy.deepcopy(signal1)
outputSignal = []
for i in range(length):
if i < length-delaySamples:
outputSignal += [ (signal1[i]+ signal2[i+delaySamples]) ]
else:
outputSignal += [ (signal1[i] * 2) ]
outputSignal = np.array(outputSignal)
outputSignal = vo.vocoder(outputSignal,P=.5)
outputSignal = np.ndarray.tolist(outputSignal)
outputSignal = [int(x) for x in outputSignal]
return outputSignal
def flangerDemo():
jfk = ut.readWaveFile(dirIn+"jfk.wav")
jfkFlanger = flanger(jfk)
ut.writeWaveFile(dirOut + "JFK_Flanger.wav", jfkFlanger)
piano = ut.readWaveFile(dirIn+"piano.wav")
pianoFlanger = flanger(piano)
ut.writeWaveFile(dirOut + "Piano_Flanger.wav", pianoFlanger)
violin = ut.readWaveFile(dirIn+"Violin2.wav")
violinFlanger = flanger(violin)
ut.writeWaveFile(dirOut + "Violin_Flanger.wav", violinFlanger)
print("Flanger Demo Complete.")
flangerDemo()
| apache-2.0 |
gcvalderrama/Palantir | Classification/trainer.py | 1 | 11921 | """
This script process all the clean news, to determine if they are into 'policiales' or 'nonattack' category
"""
import os
import glob
import random
import pickle
import unicodedata
from nltk import NaiveBayesClassifier, FreqDist, classify
from nltk.corpus import stopwords, PlaintextCorpusReader
from nltk.classify.scikitlearn import SklearnClassifier
from nltk.tokenize import word_tokenize
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from sklearn.naive_bayes import MultinomialNB, GaussianNB, BernoulliNB
from sklearn.linear_model import LogisticRegression, SGDClassifier
from sklearn.svm import SVC, LinearSVC, NuSVC
from sklearn.pipeline import Pipeline
from string import punctuation
ADDITIONAL_STOPWORDS = ['Tags', 'MÁS', 'EN', '.+MÁS', '+Tags', '...', ',', '.', '[', ']', '"', '(',
')', '…', 'el', 'la', 'los', 'uno', 'una', '-', ':', '``', "''"]
ALL_STOPWORDS = set(stopwords.words('spanish') + ADDITIONAL_STOPWORDS)
def get_documents_words(news_files, corpus_news):
"""
Given a set of documents it will return the dictionary with their
respective categories
:param news_files: List of raw news file names
:param corpus_news: PlainTextCorpusReader object
:return: Dictionary with words and categories associated
"""
root = corpus_news.root
news = []
for file in news_files:
category = file.split('/')[-1].split('--')[0]
file_name = file.replace(root, '', 1)
words = corpus_news.words(file_name[1:])
news.append((list(words), category))
random.shuffle(news)
return news
def find_features(document, word_features):
"""
Given a string with a word_features as universe,
it will return their respective features
:param document: String to generate the features to
:param word_features: Universe of words
:return: Dictionary with the features for document string
"""
words = set(document)
features = {}
for w in word_features:
features[w] = (w in words)
return features
def vectorize_documents(root_folder, extension='txt'):
"""
In construction
:param root_folder:
:param extension:
:return:
"""
# pipeline = Pipeline([
# ('vectorizer', CountVectorizer()),
# ('tfidfTrans', TfidfVectorizer()),
# ('sgdclf', SGDClassifier(loss='modied_huber'))
# ])
#
# params = { 'vectorizer__max_df': (0.5, 1.0),
# 'vectorizer__ngrams_range': {(1, 1), (1, 2)},
# 'tfidfTrans__use_idf': (True, False),
# 'sgdclf__alpha': (0.0001, 0.00001, 0.000001)
# }
vectorizer = TfidfVectorizer(sublinear_tf=True, max_df=0.5)
news_files = glob.glob(root_folder + "/*." + extension)
news_content = []
for file in news_files:
with open(file, 'r') as news_file:
content = news_file.read()
news_content.append(content)
features_train = news_content[:3]
features_test = news_content[150:]
fit = vectorizer.fit(features_train)
features_train_transformed = vectorizer.fit_transform(features_train)
features_test_transformed = vectorizer.transform(features_test)
# print(fit)
for w in features_train:
print(w)
# print(features_train)
print('TRAINED FEATURES: \n', features_train_transformed[0])
# print('TESTED FEATURES: \n', features_test_transformed[0])
def train_classifier(root_folder, train_folder, devtest_folder, files_extension='txt'):
"""
Generates .pickle file with trained classifier and words universe
:param root_folder: Folder that contains train and devtest folders
:param train_folder: Folder inside root_folder that contains the news to train with
:param devtest_folder: Folder inside root_folder that contains the new to test with
:param files_extension: File extension to search for
:return: void - empty
"""
train_news_files = glob.glob(root_folder + "/" + train_folder + "/*." + files_extension)
devtest_news_files = glob.glob(root_folder + "/" + devtest_folder + "/*." + files_extension)
corpus_news = PlaintextCorpusReader(root_folder, '.*\.' + files_extension)
words_train_docs = get_documents_words(train_news_files, corpus_news)
words_devtest_docs = get_documents_words(devtest_news_files, corpus_news)
all_words = FreqDist(word.lower() for word in corpus_news.words())
word_features = list(all_words.keys())
with open('word_features.pickle', 'wb') as words_saver:
pickle.dump(word_features, words_saver)
training_set = [(find_features(news, word_features), category) for (news, category) in words_train_docs]
with open('training_set.pickle', 'wb') as training_writer:
pickle.dump(training_set, training_writer)
testing_set = [(find_features(news, word_features), category) for (news, category) in words_devtest_docs]
with open('devtesting_set.pickle', 'wb') as devtesting_writer:
pickle.dump(testing_set, devtesting_writer)
classifier = NaiveBayesClassifier.train(training_set)
accuracy = classify.accuracy(classifier, testing_set)
print('Naive Bayes accuracy percent: ', (accuracy * 100))
classifier.show_most_informative_features(20)
# saves classifier progress to a pickle file
with open('naives_classifier.pickle', 'wb') as save_classifier:
pickle.dump(classifier, save_classifier)
def compare_classifiers_accuracy():
with open('naives_classifier.pickle', 'rb') as read_classifier:
naive_bayes_classifier = pickle.load(read_classifier)
with open('training_set.pickle', 'rb') as training_reader:
training_set = pickle.load(training_reader)
with open('devtesting_set.pickle', 'rb') as devtesting_reader:
devtesting_set = pickle.load(devtesting_reader)
accuracy = classify.accuracy(naive_bayes_classifier, devtesting_set)
print('Naive Bayes accuracy percent: ', (accuracy * 100))
mnb_classifier = SklearnClassifier(MultinomialNB())
mnb_classifier.train(training_set)
mnb_accuracy = classify.accuracy(mnb_classifier, devtesting_set)
print('MNB accuracy percent: ', (mnb_accuracy * 100))
bernoullinb_classifier = SklearnClassifier(BernoulliNB())
bernoullinb_classifier.train(training_set)
bernoullinb_accuracy = classify.accuracy(bernoullinb_classifier, devtesting_set)
print('BernoulliNB accuracy percent: ', (bernoullinb_accuracy * 100))
# gaussiannb_classifier = SklearnClassifier(GaussianNB())
# gaussiannb_classifier.train(training_set)
# gaussiannb_accuracy = classify.accuracy(gaussiannb_classifier, devtesting_set)
# print('GaussianNB accuracy percent: ', (gaussiannb_accuracy * 100))
logisticregression_classifier = SklearnClassifier(LogisticRegression())
logisticregression_classifier.train(training_set)
logisticregression_accuracy = classify.accuracy(logisticregression_classifier, devtesting_set)
print('LogisticRegression accuracy percent: ', (logisticregression_accuracy * 100))
sgdclassifier_classifier = SklearnClassifier(SGDClassifier())
sgdclassifier_classifier.train(training_set)
sgdclassifier_accuracy = classify.accuracy(sgdclassifier_classifier, devtesting_set)
print('SGDClassifier accuracy percent: ', (sgdclassifier_accuracy * 100))
svc_classifier = SklearnClassifier(SVC())
svc_classifier.train(training_set)
svc_accuracy = classify.accuracy(svc_classifier, devtesting_set)
print('SVC accuracy percent: ', (svc_accuracy * 100))
linearsvc_classifier = SklearnClassifier(LinearSVC())
linearsvc_classifier.train(training_set)
linearsvc_accuracy = classify.accuracy(linearsvc_classifier, devtesting_set)
print('LinearSVC accuracy percent: ', (linearsvc_accuracy * 100))
nusvc_classifier = SklearnClassifier(NuSVC())
nusvc_classifier.train(training_set)
nusvc_accuracy = classify.accuracy(nusvc_classifier, devtesting_set)
print('NuSVC accuracy percent: ', (nusvc_accuracy * 100))
def classify_document(file_name):
"""
Load words and naives classifier from pickle and recognize a file
:param file_name: File name for clean text
:return: Category obtained from text sent
"""
# load the pickle file with the classifier progress
with open('naives_classifier.pickle', 'rb') as read_classifier:
naive_bayes_classifier = pickle.load(read_classifier)
with open('word_features.pickle', 'rb') as words_reader:
word_features = pickle.load(words_reader)
with open(file_name, 'r') as file_text:
text = file_text.read()
text_feature = find_features(text, word_features)
result = naive_bayes_classifier.classify(text_feature)
return result
def clean_tokenize(doc):
"""
Clean document, removing accents, punctuation and symbols
:param doc: string to clean
:return: string cleaned without punctuation and stop words
"""
doc = doc.replace('\n', ' ').replace('\r', '').replace('”', '').replace('“', '')
nfkd_form = unicodedata.normalize('NFKD', doc)
unicode_doc = u"".join([c for c in nfkd_form if not unicodedata.combining(c)]).lower()
clean_doc = unicode_doc.translate(punctuation)
words = word_tokenize(clean_doc)
clean = []
for word in words:
if word not in ALL_STOPWORDS:
clean.append(word)
return clean
def tokenize_files(source_folder, destination_folder):
"""
Search for all the txt files in source folder and clean them
:param source_folder: Source folder with news to clean
:param destination_folder: Destination folder where news will be created
:return: void - Generates all the destination files with clean text
"""
news = glob.glob(source_folder + "/*.txt")
for news_file in news:
file_name = news_file.split('/')[1]
with open(news_file, 'r') as original:
doc_text = original.read()
tokenize_cont = clean_tokenize(doc_text)
with open(destination_folder+"/"+file_name, 'w') as modified:
modified.write(' '.join(tokenize_cont))
def docs_tfidf(file, max_features=5000, ngram_range=(1, 1), max_df=.8):
"""
:param file:
:param max_features:
:param ngram_range:
:param max_df:
:return:
"""
vec = TfidfVectorizer(input=file,
max_features=max_features,
ngram_range=ngram_range,
max_df=max_df)
return vec
# X = vec.fit_transform(clean_articles)
# return X, vec
def rename_files(source_folder, extension='txt'):
"""
:param source_folder:
:param extension:
:return:
"""
news = glob.glob(source_folder + "/*." + extension)
for news_file in news:
if news_file.startswith(source_folder + "/policiales--"):
updated_name = source_folder + '/attack--' + news_file.split('/')[-1].split('--')[-1]
os.rename(news_file, updated_name)
elif not news_file.startswith(source_folder + "/attack--"):
updated_name = source_folder + '/nonattack--' + news_file.split('/')[-1].split('--')[-1]
os.rename(news_file, updated_name)
def remove_first_line(source_folder, extension):
"""
:param source_folder:
:param extension:
:return:
"""
files = glob.glob(source_folder + '/*.' + extension)
for file in files:
with open(file, 'r') as fin:
data = fin.read().splitlines(True)
with open(file, 'w') as fout:
fout.writelines(data[1:])
# remove_first_line('cleanNews', 'txt')
# tokenize_files('cleanNews', 'corporaNews')
# train_classifier('corpusnews', 'train', 'devtest')
compare_classifiers_accuracy()
# classify_document('corporaNews/nonattack--india-espera-compartir-experiencias-gobierno-ppk-noticia-1910298.txt')
# vectorize_documents('corporaNews','txt')
| bsd-2-clause |
iGEM-QSF/SimCircus | visualize.py | 1 | 7330 | #!/usr/bin/env python
import matplotlib
matplotlib.use('TkAgg')
#from numpy import arange, sin, pi
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, \
NavigationToolbar2TkAgg
#from matplotlib import pyplot as plt
from matplotlib.figure import Figure
import sys
if sys.version_info[0] < 3:
import Tkinter as Tk
else:
import tkinter as Tk
class Visualization(object):
"""
Visualization is a class for visualizing any kind of time series data in
real time.
@requires:
simulation, object
@attrs
simulation.data, dictionary
Includes all the parameter names as keys and the time series
(list of values) as the values
simulation.timesteps
List of timesteps (float or integer),
same dimension as every paramter
simulation.ib, float
Blue light intensity parameter with value between 0.0 and 1.0
start()
Initializes the GUI, required to visualize the simulation
update()
Updates the data in the graph
start() has to be run before calling this function
Example 1:
vis = Visualization(simulation)
vis.start()
for i in range(1000):
simulation.iteration()
vis.update()
The previous example updates the simulation data in each timestep
Example 2:
import random
import threading
class FakeSimulation(threading.Thread):
def __init__(self):
#Threading actions, non threaded example may be feasible
#now that a new visualization version was made.
threading.Thread.__init__(self)
self.data = {
"Parameter 1": [],
"Parameter 2": []
}
self.timesteps = []
self.vis = Visualization(self)
self.vis.start()
def run(self):
for i in range(100):
print i
self.data["Parameter 1"].append(random.randint(1, 15))
self.data["Parameter 2"].append(random.randint(1, 15))
self.timesteps.append(i)
self.vis.update()
sim = FakeSimulation()
sim.start() #May not be necessary
The example 2 is a ready copy-and-paste demonstration of how this works.
"""
def __init__(self, simulation):
#Initialize drawing parameters
self.simulation = simulation
self.legend = simulation.data.keys()
self.toggle_list = [1 for i in simulation.data.keys()]
self.colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k', 'm:', 'b:']
self.graph = 0
def start(self):
#Tkinter related actions
self.root = Tk.Tk()
self.root.wm_title('SimCircusVisualizer 3000 Ultra+ by Aalto-Helsinki')
button = Tk.Button(master=self.root, text='Quit', command=self._quit)
button.pack(side=Tk.BOTTOM)
# Creating the right sidebar
self.button_frame = Tk.Frame(self.root)
buttons = []
for ind, parameter in enumerate(self.simulation.data.keys()):
temp = Tk.Button(
master=self.button_frame,
text=parameter,
command=lambda ind=ind: self.toggle(ind))
temp.pack(side=Tk.TOP)
buttons.append(temp)
self.blue_intensity = Tk.DoubleVar()
scale_blue = Tk.Scale(
self.button_frame,
variable=self.blue_intensity,
label="Blue intensity",
from_=1.0,
to=0.0,
resolution=0.01,
command=self.set_blue_intensity)
scale_blue.pack(side=Tk.BOTTOM)
self.red_intensity = Tk.DoubleVar()
scale_red = Tk.Scale(
self.button_frame,
variable=self.red_intensity,
label="Red intensity",
from_=1.0,
to=0.0,
resolution=0.01,
command=self.set_red_intensity)
scale_red.pack(side=Tk.BOTTOM)
toggle = Tk.Button(
master=self.button_frame,
text="Graph",
command=self.toggle_graph)
toggle.pack(side=Tk.TOP)
self.button_frame.pack(side=Tk.RIGHT)
# DrawingArea
self.figure = Figure(figsize=(10, 8), dpi=100)
self.canvas = FigureCanvasTkAgg(self.figure, master=self.root)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.root)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.root.after(0, self.simulation.start)
self.root.mainloop()
def toggle_graph(self):
self.graph += 1
if self.graph == 3:
self.graph = 0
def update(self):
'''
Visualizes the current situation
'''
active_legend = [legend for ind, legend in enumerate(self.legend)
if self.toggle_list[ind]]
self.figure.clf()
if self.graph in [0, 2]:
subplot = 111
if self.graph == 2:
subplot = 211
a = self.figure.add_subplot(
subplot,
xlabel="Time",
ylabel="Protein concentration")
for ind, parameter in enumerate(self.simulation.data.keys()):
if self.toggle_list[ind]:
a.plot(
self.simulation.timesteps,
self.simulation.data.get(parameter),
self.colors[ind])
a.set_xlim(0, max(self.simulation.timesteps))
if self.graph in [1, 2]:
subplot = 111
if self.graph == 2:
subplot = 212
a = self.figure.add_subplot(
subplot,
xlabel="Time",
ylabel="Protein concentration")
for ind, parameter in enumerate(self.simulation.data.keys()):
if self.toggle_list[ind]:
a.plot(
self.simulation.timesteps[-50:],
self.simulation.data.get(parameter)[-50:],
self.colors[ind])
a.set_xlim(
max([0, self.simulation.timesteps[max(
[0, len(self.simulation.timesteps) - 50]
)
]]),
max(self.simulation.timesteps)
)
a.legend(active_legend, "upper left")
self.canvas.show()
self.toolbar.update()
def set_blue_intensity(self, current_value):
self.simulation.blue_intensity = float(current_value)
def set_red_intensity(self, current_value):
self.simulation.red_intensity = float(current_value)
def toggle(self, ind):
if self.toggle_list[ind]:
self.toggle_list[ind] = 0
else:
self.toggle_list[ind] = 1
self.update()
def _quit(self):
self.root.quit() # stops mainloop
self.root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
| mit |
deepchem/deepchem | examples/kaggle/KAGGLE_rf_model.py | 6 | 3245 | """
Script that trains RF model on KAGGLE datasets.
"""
from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals
import os
import numpy as np
import tempfile
import shutil
import deepchem as dc
from sklearn.ensemble import RandomForestRegressor
from deepchem.molnet import load_kaggle
###Load data###
np.random.seed(123)
shard_size = 2000
num_trials = 5
print("About to load KAGGLE data.")
KAGGLE_tasks, datasets, transformers = load_kaggle(shard_size=shard_size)
train_dataset, valid_dataset, test_dataset = datasets
print("Number of compounds in train set")
print(len(train_dataset))
print("Number of compounds in validation set")
print(len(valid_dataset))
print("Number of compounds in test set")
print(len(test_dataset))
num_features = train_dataset.get_data_shape()[0]
print("Num features: %d" % num_features)
metric = dc.metrics.Metric(dc.metrics.pearson_r2_score, task_averager=np.mean)
def task_model_builder(model_dir):
sklearn_model = RandomForestRegressor(
#n_estimators=100, max_features=int(num_features/3),
n_estimators=1,
max_features=int(num_features / 3),
min_samples_split=5,
n_jobs=-1)
return dc.models.SklearnModel(sklearn_model, model_dir)
all_results = []
for trial in range(num_trials):
print("Starting trial %d" % trial)
model = dc.models.SingletaskToMultitask(KAGGLE_tasks, task_model_builder)
print("Training model")
model.fit(train_dataset)
print("Evaluating models")
train_score, train_task_scores = model.evaluate(
train_dataset, [metric], transformers, per_task_metrics=True)
valid_score, valid_task_scores = model.evaluate(
valid_dataset, [metric], transformers, per_task_metrics=True)
test_score, test_task_scores = model.evaluate(
test_dataset, [metric], transformers, per_task_metrics=True)
all_results.append((train_score, train_task_scores, valid_score,
valid_task_scores, test_score, test_task_scores))
print("----------------------------------------------------------------")
print("Scores for trial %d" % trial)
print("----------------------------------------------------------------")
print("train_task_scores")
print(train_task_scores)
print("Mean Train score")
print(train_score)
print("valid_task_scores")
print(valid_task_scores)
print("Mean Validation score")
print(valid_score)
print("test_task_scores")
print(test_task_scores)
print("Mean Test score")
print(test_score)
print("####################################################################")
for trial in range(num_trials):
(train_score, train_task_scores, valid_score, valid_task_scores, test_score,
test_task_scores) = all_results[trial]
print("----------------------------------------------------------------")
print("Scores for trial %d" % trial)
print("----------------------------------------------------------------")
print("train_task_scores")
print(train_task_scores)
print("Mean Train score")
print(train_score)
print("valid_task_scores")
print(valid_task_scores)
print("Mean Validation score")
print(valid_score)
print("test_task_scores")
print(test_task_scores)
print("Mean Test score")
print(test_score)
| mit |
toastedcornflakes/scikit-learn | sklearn/feature_selection/tests/test_rfe.py | 33 | 10515 | """
Testing Recursive feature elimination
"""
import warnings
import numpy as np
from numpy.testing import assert_array_almost_equal, assert_array_equal
from nose.tools import assert_equal, assert_true
from scipy import sparse
from sklearn.feature_selection.rfe import RFE, RFECV
from sklearn.datasets import load_iris, make_friedman1
from sklearn.metrics import zero_one_loss
from sklearn.svm import SVC, SVR
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.utils import check_random_state
from sklearn.utils.testing import ignore_warnings
from sklearn.utils.testing import assert_warns_message
from sklearn.utils.testing import assert_greater
from sklearn.metrics import make_scorer
from sklearn.metrics import get_scorer
class MockClassifier(object):
"""
Dummy classifier to test recursive feature elimination
"""
def __init__(self, foo_param=0):
self.foo_param = foo_param
def fit(self, X, Y):
assert_true(len(X) == len(Y))
self.coef_ = np.ones(X.shape[1], dtype=np.float64)
return self
def predict(self, T):
return T.shape[0]
predict_proba = predict
decision_function = predict
transform = predict
def score(self, X=None, Y=None):
if self.foo_param > 1:
score = 1.
else:
score = 0.
return score
def get_params(self, deep=True):
return {'foo_param': self.foo_param}
def set_params(self, **params):
return self
def test_rfe_features_importance():
generator = check_random_state(0)
iris = load_iris()
X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
y = iris.target
clf = RandomForestClassifier(n_estimators=20,
random_state=generator, max_depth=2)
rfe = RFE(estimator=clf, n_features_to_select=4, step=0.1)
rfe.fit(X, y)
assert_equal(len(rfe.ranking_), X.shape[1])
clf_svc = SVC(kernel="linear")
rfe_svc = RFE(estimator=clf_svc, n_features_to_select=4, step=0.1)
rfe_svc.fit(X, y)
# Check if the supports are equal
assert_array_equal(rfe.get_support(), rfe_svc.get_support())
def test_rfe():
generator = check_random_state(0)
iris = load_iris()
X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
X_sparse = sparse.csr_matrix(X)
y = iris.target
# dense model
clf = SVC(kernel="linear")
rfe = RFE(estimator=clf, n_features_to_select=4, step=0.1)
rfe.fit(X, y)
X_r = rfe.transform(X)
clf.fit(X_r, y)
assert_equal(len(rfe.ranking_), X.shape[1])
# sparse model
clf_sparse = SVC(kernel="linear")
rfe_sparse = RFE(estimator=clf_sparse, n_features_to_select=4, step=0.1)
rfe_sparse.fit(X_sparse, y)
X_r_sparse = rfe_sparse.transform(X_sparse)
assert_equal(X_r.shape, iris.data.shape)
assert_array_almost_equal(X_r[:10], iris.data[:10])
assert_array_almost_equal(rfe.predict(X), clf.predict(iris.data))
assert_equal(rfe.score(X, y), clf.score(iris.data, iris.target))
assert_array_almost_equal(X_r, X_r_sparse.toarray())
def test_rfe_mockclassifier():
generator = check_random_state(0)
iris = load_iris()
X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
y = iris.target
# dense model
clf = MockClassifier()
rfe = RFE(estimator=clf, n_features_to_select=4, step=0.1)
rfe.fit(X, y)
X_r = rfe.transform(X)
clf.fit(X_r, y)
assert_equal(len(rfe.ranking_), X.shape[1])
assert_equal(X_r.shape, iris.data.shape)
def test_rfecv():
generator = check_random_state(0)
iris = load_iris()
X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
y = list(iris.target) # regression test: list should be supported
# Test using the score function
rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5)
rfecv.fit(X, y)
# non-regression test for missing worst feature:
assert_equal(len(rfecv.grid_scores_), X.shape[1])
assert_equal(len(rfecv.ranking_), X.shape[1])
X_r = rfecv.transform(X)
# All the noisy variable were filtered out
assert_array_equal(X_r, iris.data)
# same in sparse
rfecv_sparse = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5)
X_sparse = sparse.csr_matrix(X)
rfecv_sparse.fit(X_sparse, y)
X_r_sparse = rfecv_sparse.transform(X_sparse)
assert_array_equal(X_r_sparse.toarray(), iris.data)
# Test using a customized loss function
scoring = make_scorer(zero_one_loss, greater_is_better=False)
rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5,
scoring=scoring)
ignore_warnings(rfecv.fit)(X, y)
X_r = rfecv.transform(X)
assert_array_equal(X_r, iris.data)
# Test using a scorer
scorer = get_scorer('accuracy')
rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5,
scoring=scorer)
rfecv.fit(X, y)
X_r = rfecv.transform(X)
assert_array_equal(X_r, iris.data)
# Test fix on grid_scores
def test_scorer(estimator, X, y):
return 1.0
rfecv = RFECV(estimator=SVC(kernel="linear"), step=1, cv=5,
scoring=test_scorer)
rfecv.fit(X, y)
assert_array_equal(rfecv.grid_scores_, np.ones(len(rfecv.grid_scores_)))
# Same as the first two tests, but with step=2
rfecv = RFECV(estimator=SVC(kernel="linear"), step=2, cv=5)
rfecv.fit(X, y)
assert_equal(len(rfecv.grid_scores_), 6)
assert_equal(len(rfecv.ranking_), X.shape[1])
X_r = rfecv.transform(X)
assert_array_equal(X_r, iris.data)
rfecv_sparse = RFECV(estimator=SVC(kernel="linear"), step=2, cv=5)
X_sparse = sparse.csr_matrix(X)
rfecv_sparse.fit(X_sparse, y)
X_r_sparse = rfecv_sparse.transform(X_sparse)
assert_array_equal(X_r_sparse.toarray(), iris.data)
def test_rfecv_mockclassifier():
generator = check_random_state(0)
iris = load_iris()
X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
y = list(iris.target) # regression test: list should be supported
# Test using the score function
rfecv = RFECV(estimator=MockClassifier(), step=1, cv=5)
rfecv.fit(X, y)
# non-regression test for missing worst feature:
assert_equal(len(rfecv.grid_scores_), X.shape[1])
assert_equal(len(rfecv.ranking_), X.shape[1])
def test_rfe_estimator_tags():
rfe = RFE(SVC(kernel='linear'))
assert_equal(rfe._estimator_type, "classifier")
# make sure that cross-validation is stratified
iris = load_iris()
score = cross_val_score(rfe, iris.data, iris.target)
assert_greater(score.min(), .7)
def test_rfe_min_step():
n_features = 10
X, y = make_friedman1(n_samples=50, n_features=n_features, random_state=0)
n_samples, n_features = X.shape
estimator = SVR(kernel="linear")
# Test when floor(step * n_features) <= 0
selector = RFE(estimator, step=0.01)
sel = selector.fit(X, y)
assert_equal(sel.support_.sum(), n_features // 2)
# Test when step is between (0,1) and floor(step * n_features) > 0
selector = RFE(estimator, step=0.20)
sel = selector.fit(X, y)
assert_equal(sel.support_.sum(), n_features // 2)
# Test when step is an integer
selector = RFE(estimator, step=5)
sel = selector.fit(X, y)
assert_equal(sel.support_.sum(), n_features // 2)
def test_number_of_subsets_of_features():
# In RFE, 'number_of_subsets_of_features'
# = the number of iterations in '_fit'
# = max(ranking_)
# = 1 + (n_features + step - n_features_to_select - 1) // step
# After optimization #4534, this number
# = 1 + np.ceil((n_features - n_features_to_select) / float(step))
# This test case is to test their equivalence, refer to #4534 and #3824
def formula1(n_features, n_features_to_select, step):
return 1 + ((n_features + step - n_features_to_select - 1) // step)
def formula2(n_features, n_features_to_select, step):
return 1 + np.ceil((n_features - n_features_to_select) / float(step))
# RFE
# Case 1, n_features - n_features_to_select is divisible by step
# Case 2, n_features - n_features_to_select is not divisible by step
n_features_list = [11, 11]
n_features_to_select_list = [3, 3]
step_list = [2, 3]
for n_features, n_features_to_select, step in zip(
n_features_list, n_features_to_select_list, step_list):
generator = check_random_state(43)
X = generator.normal(size=(100, n_features))
y = generator.rand(100).round()
rfe = RFE(estimator=SVC(kernel="linear"),
n_features_to_select=n_features_to_select, step=step)
rfe.fit(X, y)
# this number also equals to the maximum of ranking_
assert_equal(np.max(rfe.ranking_),
formula1(n_features, n_features_to_select, step))
assert_equal(np.max(rfe.ranking_),
formula2(n_features, n_features_to_select, step))
# In RFECV, 'fit' calls 'RFE._fit'
# 'number_of_subsets_of_features' of RFE
# = the size of 'grid_scores' of RFECV
# = the number of iterations of the for loop before optimization #4534
# RFECV, n_features_to_select = 1
# Case 1, n_features - 1 is divisible by step
# Case 2, n_features - 1 is not divisible by step
n_features_to_select = 1
n_features_list = [11, 10]
step_list = [2, 2]
for n_features, step in zip(n_features_list, step_list):
generator = check_random_state(43)
X = generator.normal(size=(100, n_features))
y = generator.rand(100).round()
rfecv = RFECV(estimator=SVC(kernel="linear"), step=step, cv=5)
rfecv.fit(X, y)
assert_equal(rfecv.grid_scores_.shape[0],
formula1(n_features, n_features_to_select, step))
assert_equal(rfecv.grid_scores_.shape[0],
formula2(n_features, n_features_to_select, step))
def test_rfe_cv_n_jobs():
generator = check_random_state(0)
iris = load_iris()
X = np.c_[iris.data, generator.normal(size=(len(iris.data), 6))]
y = iris.target
rfecv = RFECV(estimator=SVC(kernel='linear'))
rfecv.fit(X, y)
rfecv_ranking = rfecv.ranking_
rfecv_grid_scores = rfecv.grid_scores_
rfecv.set_params(n_jobs=2)
rfecv.fit(X, y)
assert_array_almost_equal(rfecv.ranking_, rfecv_ranking)
assert_array_almost_equal(rfecv.grid_scores_, rfecv_grid_scores)
| bsd-3-clause |
losonczylab/Zaremba_NatNeurosci_2017 | losonczy_analysis_bundle/lab/figures/analysisFigures.py | 1 | 99631 | """Figure generating functions to accompany behavior_analysis,
used by automatic scripts
All functions should return either a figure or list of figures.
"""
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import itertools as it
from scipy.misc import comb
try:
from bottleneck import nanmean, nanstd
except ImportError:
from numpy import nanmean, nanstd
from warnings import warn
import pandas as pd
import seaborn.apionly as sns
from collections import defaultdict
from copy import copy
import lab
from ..analysis import imaging_analysis as ia
from ..analysis import signals_analysis as sa
from ..analysis import reward_analysis as ra
from ..analysis import intervals as inter
from ..analysis import filters as af
from ..classes.classes import ExperimentGroup as eg
from .. import plotting
from .. import misc
from ..plotting import plot_metric, plot_paired_metrics, color_cycle
import lab.plotting.analysis_plotting as ap
def activityByExposureFigure(exptGrp, rasterized=False, **kwargs):
fig, axs = plt.subplots(2, 3, figsize=(15, 8))
ap.activityByExposure(
exptGrp, ax=axs[0][0], stat='mean', rasterized=rasterized, **kwargs)
ap.activityByExposure(
exptGrp, ax=axs[0][1], stat='responseMagnitude',
rasterized=rasterized, **kwargs)
ap.activityByExposure(
exptGrp, ax=axs[0][2], stat='norm transient auc2',
rasterized=rasterized, **kwargs)
ap.activityByExposure(
exptGrp, ax=axs[1][0], stat='amplitude', rasterized=rasterized,
**kwargs)
ap.activityByExposure(
exptGrp, ax=axs[1][1], stat='duration', rasterized=rasterized,
**kwargs)
ap.activityByExposure(
exptGrp, ax=axs[1][2], stat='frequency', rasterized=rasterized,
**kwargs)
return fig
def activityComparisonFigure(exptGrp, method='mean', rasterized=False):
nCols = 4
exposure = exptGrp.priorDaysOfExposure(ignoreContext=False)
pairs = it.combinations(exptGrp, 2)
nPairs = 0
valid_pairs = []
# A valid experiment pair is from the same mouse and either the same
# context or the same day of exposure
for pair in pairs:
if (pair[0].parent == pair[1].parent) \
and (pair[0].sameContext(pair[1]) or
(exposure[pair[0]] == exposure[pair[1]])):
valid_pairs.append(pair)
nPairs += 1
nFigs = int(np.ceil(nPairs / float(nCols)))
figs = []
axs = []
for f in range(nFigs):
fig, ax = plt.subplots(2, nCols, figsize=(15, 8), squeeze=False)
ax_pairs = [(ax[0][x], ax[1][x]) for x in range(nCols)]
axs.extend(ax_pairs)
figs.append(fig)
n_extras = (nFigs * nCols) - nPairs
if n_extras > 0:
for a in axs[-n_extras:]:
a[0].set_visible(False)
a[1].set_visible(False)
for pair, ax in it.izip(valid_pairs, axs):
grp = lab.ExperimentGroup(pair)
label1 = 'Day {}, Ctx {}'.format(
exposure[grp[0]] + 1, grp[0].get('environment'))
label2 = 'Day {}, Ctx {}'.format(
exposure[grp[1]] + 1, grp[1].get('environment'))
ap.activityComparisonPlot(
grp, method=method, ax=ax[0], mask1=None, mask2=None, label1=label1,
label2=label2, roiNamesToLabel=None, normalize=False,
rasterized=rasterized, dF='from_file')
grp2 = lab.ExperimentGroup(pair[::-1])
ap.activityComparisonPlot(
grp2, method=method, ax=ax[1], mask1=None, mask2=None, label1=label2,
label2=label1, roiNamesToLabel=None, normalize=False,
rasterized=rasterized, dF='from_file')
return figs
def salience_responses_figures(
exptGrp, stimuli, pre_time=None, post_time=None, channel='Ch2',
label=None, roi_filter=None, exclude_running=False, rasterized=False):
"""Plot each ROI's response to each stim in stimuli"""
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
# Stims labeled 'off' just flip the tail of the responsive distribution
# but are actually the same PSTH as the 'on' version
# No need to plot both
stimuli = [stim for stim in stimuli if 'off' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return []
cmap = matplotlib.cm.get_cmap(name='Spectral')
color_cycle = [cmap(i) for i in np.linspace(0, 0.9, len(stimuli))]
psths = []
for stim in stimuli:
psth, rois, x_ranges = ia.PSTH(
exptGrp, stimulus=stim, channel=channel, label=label, roi_filter=roi_filter,
pre_time=pre_time, post_time=post_time,
exclude='running' if exclude_running else None)
psths.append(psth)
figs, axs, axs_to_label = plotting.layout_subplots(
n_plots=len(psths[0]) + 1, rows=3, cols=4, polar=False,
sharex=False, figsize=(15, 8), rasterized=rasterized)
for fig in figs:
fig.suptitle('Salience Responses: {}'.format(
'running excluded' if exclude_running else 'running included'))
for psth, color, stim in it.izip(psths, color_cycle, stimuli):
for ax, roi_psth, roi, x_range in it.izip(axs, psth, rois, x_ranges):
ax.plot(x_range, roi_psth, color=color)
ax.set_title(roi[0].get('mouseID') + ', ' + roi[1] + ', ' + roi[2])
ax.axvline(0, linestyle='dashed', color='k')
ax.set_xlim(x_range[0], x_range[-1])
ylims = np.round(ax.get_ylim(), 2)
if ylims[1] != 0:
ax.set_yticks([0, ylims[1]])
elif ylims[0] != 0:
ax.set_yticks([ylims[0], 0])
else:
ax.set_yticks([0])
if ax not in axs_to_label:
ax.tick_params(labelbottom=False)
# Last axis will just be for labels
axs[-1].plot([0, 1],
[-color_cycle.index(color), -color_cycle.index(color)],
color=color, label=stim)
axs[-1].set_xlim(0, 1)
axs[-1].set_ylim(-len(stimuli), 1)
axs[-1].tick_params(labelbottom=False, labelleft=False, bottom=False,
left=False, top=False, right=False)
axs[-1].legend()
for ax in axs_to_label:
ax.set_ylabel(r'Average $\Delta$F/F')
ax.set_xlabel('Time (s)')
return figs
def salience_expt_summary_figure(
expt, stimuli, method='responsiveness', pre_time=None, post_time=None,
channel='Ch2', label=None, roi_filter=None, exclude_running=False,
rasterized=False, n_processes=1):
"""Summary of salience responses.
Includes trialAverageHeatmap, psth of responsive ROIs and image overlay of
responsive ROIs.
"""
fig, axs = plt.subplots(3, len(stimuli), figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
fig.suptitle('Salience Experiment Summary: {}'.format(
'running excluded' if exclude_running else 'running included'))
frame_period = expt.frame_period()
pre_frames = None if pre_time is None else int(pre_time / frame_period)
post_frames = None if post_time is None else int(post_time / frame_period)
for stim_idx, stim in enumerate(stimuli):
expt.trialAverageHeatmap(
stimulus=stim, ax=axs[0, stim_idx], sort=False, smoothing=None,
window_length=5, channel=channel, label=label,
roi_filter=roi_filter, exclude_running=exclude_running)
axs[0, stim_idx].set_title(stim)
responsive_filter = af.identify_stim_responsive_cells(
expt, stimulus=stim, method=method, pre_frames=pre_frames,
post_frames=post_frames, data=None, ax=axs[1, stim_idx],
conf_level=95, sig_tail='upper', transients_conf_level=95,
plot_mean=True, exclude='running' if exclude_running else None,
channel=channel, label=label, roi_filter=roi_filter,
n_bootstraps=10000, save_to_expt=True, n_processes=n_processes)
rois = expt.roiVertices(
channel=channel, label=label, roi_filter=responsive_filter)
plotting.roiDataImageOverlay(
ax=axs[2, stim_idx],
background=expt.returnFinalPrototype(channel=channel),
rois=rois, values=None, vmin=0, vmax=.8)
return fig
def salience_exptGrp_summary_figure(
exptGrp, stimuli, method='responsiveness', pre_time=None,
post_time=None, channel='Ch2', label=None, roi_filter=None,
exclude_running=False, rasterized=False, save_data=False,
n_processes=1, n_bootstraps=10000):
STIMS_PER_FIG = 6
data_to_save = {}
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return []
n_figs = int(np.ceil(len(stimuli) / float(STIMS_PER_FIG)))
figs, psth_axs, response_axs, fraction_axs, first_col_axs = \
[], [], [], [], []
for n in range(n_figs):
fig, axs = plt.subplots(
3, STIMS_PER_FIG, figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
fig.suptitle('Responsive ROIs summary: {}'.format(
'running excluded' if exclude_running else 'running included'))
figs.append(fig)
psth_axs.append(axs[0, :])
response_axs.append(axs[1, :])
fraction_axs.append(axs[2, :])
first_col_axs.append(axs[:, 0])
psth_axs = np.hstack(psth_axs)
response_axs = np.hstack(response_axs)
fraction_axs = np.hstack(fraction_axs)
first_col_axs = np.hstack(first_col_axs)
min_psth_y_lim = np.inf
max_psth_y_lim = -np.inf
responsive_cells = {}
for ax, stimulus in it.izip(psth_axs, stimuli):
responsive_cells[stimulus] = ia.identify_stim_responsive_cells(
exptGrp, stimulus=stimulus, method=method, ax=ax, pre_time=pre_time,
post_time=post_time, data=None, conf_level=95, sig_tail='upper',
plot_mean=True, exclude='running' if exclude_running else None,
channel=channel, label=label, roi_filter=roi_filter,
n_bootstraps=n_bootstraps, save_to_expt=True,
n_processes=n_processes)
ax.set_title(stimulus)
min_psth_y_lim = np.amin([min_psth_y_lim, ax.get_ylim()[0]])
max_psth_y_lim = np.amax([max_psth_y_lim, ax.get_ylim()[1]])
max_bar_y_lim = 0
n_responsive_rois = {}
data_to_save['responsive_responses'] = []
data_to_save['non_responsive_responses'] = []
for ax, stimulus in it.izip(response_axs, stimuli):
responses = ia.response_magnitudes(
exptGrp, stimulus, method=method, pre_time=pre_time, post_time=post_time,
data=None, exclude='running' if exclude_running else None,
channel=channel, label=label,
roi_filter=responsive_cells[stimulus])
data_to_save['responsive_responses'].append(
[stimulus] + ['{:f}'.format(val) for val in responses])
plotting.scatter_bar(
ax, [np.abs(responses)], labels=[''], jitter_x=True)
max_bar_y_lim = np.amax([max_bar_y_lim, ax.get_ylim()[1]])
ax.tick_params(bottom=False, labelbottom=False)
n_responsive_rois[stimulus] = len(responses)
non_responses = ia.response_magnitudes(
exptGrp, stimulus, method=method, pre_time=pre_time, post_time=post_time,
data=None, exclude='running' if exclude_running else None,
channel=channel, label=label,
roi_filter=misc.invert_filter(responsive_cells[stimulus]))
data_to_save['non_responsive_responses'].append(
[stimulus] + ['{:f}'.format(val) for val in non_responses])
fractions = []
n_rois = {}
for ax, stimulus in it.izip(fraction_axs, stimuli):
all_psths, _, _ = ia.PSTH(
exptGrp, stimulus=stimulus, pre_time=pre_time, post_time=post_time,
data=None, exclude='running' if exclude_running else None,
channel=channel, label=label, roi_filter=roi_filter)
# Find how many of the ROIs were imaged with the current stimulus
n_rois[stimulus] = np.sum(
[not np.all(np.isnan(psth)) for psth in all_psths])
# n_responsive_rois = len(responsive_psths[stimulus])
if n_rois[stimulus] > 0:
fractions.append(
n_responsive_rois[stimulus] / float(n_rois[stimulus]))
plotting.scatter_bar(
ax, [[fractions[-1]]],
labels=['{} / {}'.format(
n_responsive_rois[stimulus], n_rois[stimulus])],
jitter_x=False)
else:
fractions.append(np.nan)
ax.set_ylim(0, 1)
ax.tick_params(bottom=False)
for ax in set(psth_axs).difference(first_col_axs):
ax.set_xlabel('')
ax.set_ylabel('')
ax.tick_params(labelleft=False, labelbottom=False)
for ax in psth_axs:
ax.set_ylim(min_psth_y_lim, max_psth_y_lim)
for ax in set(response_axs).intersection(first_col_axs):
ax.set_ylabel('Stim response')
for ax in set(response_axs).difference(first_col_axs):
ax.tick_params(labelleft=False)
for ax in response_axs:
ax.set_ylim(0, max_bar_y_lim)
for ax in set(fraction_axs).intersection(first_col_axs):
ax.set_ylabel('Responsive cell fraction')
for ax in set(fraction_axs).difference(first_col_axs):
ax.tick_params(labelleft=False)
if len(stimuli) % STIMS_PER_FIG:
extra_axs = len(stimuli) - n_figs * STIMS_PER_FIG
for ax in it.chain(psth_axs[extra_axs:], response_axs[extra_axs:],
fraction_axs[extra_axs:]):
ax.set_visible(False)
if save_data:
# Need to update for multiple pages
raise NotImplemented
psths = {}
non_responsive_psths = {}
for stimulus in stimuli:
# Responders
psth, x_range = ia.PSTH(
exptGrp, stimulus=stimulus, pre_time=pre_time, post_time=post_time,
channel=channel, label=label,
roi_filter=responsive_cells[stimulus], return_full='norm',
exclude='running' if exclude_running else None)
psth_list = [x_range]
for roi in psth:
psth_list.append(['{:f}'.format(val) for val in roi])
label_strs = np.array(
['Time (s)'] + ['ROI ' + str(x) for x in range(psth.shape[0])])
psths[stimulus] = np.hstack([label_strs[:, None], psth_list])
# Non-responders
psth, x_range = ia.PSTH(
exptGrp, stimulus=stimulus, pre_time=pre_time, post_time=post_time,
channel=channel, label=label,
roi_filter=misc.invert_filter(responsive_cells[stimulus]),
return_full='norm', exclude='running' if exclude_running else None)
psth_list = [x_range]
for roi in psth:
psth_list.append(['{:f}'.format(val) for val in roi])
label_strs = np.array(
['Time (s)'] + ['ROI ' + str(x) for x in range(psth.shape[0])])
non_responsive_psths[stimulus] = np.hstack([label_strs[:, None], psth_list])
data_to_save['psths'] = psths
data_to_save['non_responsive_psths'] = non_responsive_psths
data_to_save['fractions'] = [stimuli, fractions]
data_to_save['n_responding'] = [
stimuli, [n_responsive_rois[stim] for stim in stimuli]]
data_to_save['n_rois'] = [stimuli, [n_rois[stim] for stim in stimuli]]
misc.save_data(
data_to_save, fig=fig, label='salience_summary', method=save_data)
return figs
def salience_expt_grp_dataframe_figure(
expt_grps, stimuli, plotby, method='responsiveness', pre_time=None,
post_time=None, channel='Ch2', label=None, roi_filters=None,
colors=None, exclude_running=False, rasterized=False, save_data=False,
n_bootstraps=10000, n_processes=1):
# data_to_save = {}
STIMS_PER_FIG = 4
if roi_filters is None:
roi_filters = [None] * len(expt_grps)
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return []
n_figs = int(np.ceil(len(stimuli) / float(STIMS_PER_FIG)))
figs, response_axs, fraction_axs, first_col_axs = [], [], [], []
for n in range(n_figs):
fig, axs = plt.subplots(
2, STIMS_PER_FIG, figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
fig.suptitle('Responsive ROIs by {}: {}'.format(
plotby,
'running excluded' if exclude_running else 'running included'))
figs.append(fig)
response_axs.append(axs[0, :])
fraction_axs.append(axs[1, :])
first_col_axs.append(axs[:, 0])
response_axs = np.hstack(response_axs)
fraction_axs = np.hstack(fraction_axs)
first_col_axs = np.hstack(first_col_axs)
if method == 'responsiveness':
activity_label = 'Responsiveness (dF/F)'
elif method == 'peak':
activity_label = 'Peak responsiveness (dF/F)'
else:
raise ValueError("Unrecognized 'method' value")
responsive_cells = {}
responsive_dfs = {}
for stimulus in stimuli:
responsive_cells[stimulus] = []
responsive_dfs[stimulus] = []
stimulus_filters = {}
stimulus_dfs = {}
for expt_grp, roi_filter in it.izip(expt_grps, roi_filters):
stimulus_filters = []
stimulus_dfs = []
for key, grp in expt_grp.groupby(plotby):
stimulus_filters.append(
ia.identify_stim_responsive_cells(
grp, stimulus=stimulus, method=method, pre_time=pre_time,
post_time=post_time, data=None, conf_level=95,
sig_tail='upper',
exclude='running' if exclude_running else None,
channel=channel, label=label, roi_filter=roi_filter,
n_bootstraps=n_bootstraps, save_to_expt=True,
n_processes=n_processes))
df = ia.response_magnitudes(
grp, stimulus, method=method, pre_time=pre_time,
post_time=post_time, data=None,
exclude='running' if exclude_running else None,
channel=channel, label=label,
roi_filter=stimulus_filters[-1], return_df=True)
# Put the grouping info back in the dataframe
# For example:
# plotby = ['condition_day']
# keys will be ['A_0', 'A_1', 'B_0', etc...]
# So df['condition_day'] == 'A_0' for the first group, etc.
for key_value, grouping in zip(key, plotby):
df[grouping] = key_value
stimulus_dfs.append(df)
responsive_dfs[stimulus].append(pd.concat(
stimulus_dfs, ignore_index=True))
responsive_cells[stimulus].append(misc.filter_union(
stimulus_filters))
#
# Plot mean PSTH for each stim/group
#
pass
#
# Plot the mean response of responsive cells
#
max_response_y_lim = 0
for ax, stimulus in it.izip(response_axs, stimuli):
plotting.plot_dataframe(
ax, responsive_dfs[stimulus],
labels=[expt_grp.label() for expt_grp in expt_grps],
activity_label=activity_label, groupby=None, plotby=plotby,
orderby=None, plot_method='line', plot_shuffle=False,
shuffle_plotby=False, pool_shuffle=False,
agg_fn=np.mean, colors=colors)
max_response_y_lim = np.amax([max_response_y_lim, ax.get_ylim()[1]])
ax.set_title(stimulus)
plt.setp(ax.get_xticklabels(), rotation='40',
horizontalalignment='right')
#
# Plot fraction of responsive ROIs
#
groupby = [['mouseID', 'uniqueLocationKey', 'roi_id'] + plotby,
['mouseID'] + plotby]
activity_kwargs = [
{'channel': channel, 'label': label, 'include_roi_filter': inc_filter}
for inc_filter in roi_filters]
for ax, stimulus in it.izip(fraction_axs, stimuli):
plot_metric(
ax, expt_grps, eg.filtered_rois, 'line',
roi_filters=responsive_cells[stimulus], groupby=groupby,
plotby=plotby, orderby=None, plot_shuffle=False,
shuffle_plotby=False, pool_shuffle=False, plot_abs=False,
activity_kwargs=activity_kwargs,
activity_label='Fraction responding', label_every_n=1,
rotate_labels=True, colors=colors)
# ax.set_ylim(0, 1)
ax.set_ylim(-0.05, 1.05)
ax.set_yticks([0, 0.2, 0.4, 0.6, 0.8, 1])
for ax in set(response_axs).difference(first_col_axs):
ax.set_ylabel('')
for ax in response_axs:
ax.set_ylim(0, max_response_y_lim)
ax.set_xlabel('')
for ax in set(fraction_axs).difference(first_col_axs):
ax.set_ylabel('')
ax.set_title('')
if len(stimuli) % STIMS_PER_FIG:
extra_axs = len(stimuli) - n_figs * STIMS_PER_FIG
for ax in it.chain(response_axs[extra_axs:], fraction_axs[extra_axs:]):
ax.set_visible(False)
return figs
def compare_psth_summary_figure(
expt_grps, stimuli, pre_time=None, post_time=None, channel='Ch2',
label=None, roi_filters=None, colors=None, exclude_running=False,
rasterized=False):
STIMS_PER_FIG = 6
if colors is None:
colors = sns.color_palette()
data_to_save = {}
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return []
n_figs = int(np.ceil(len(stimuli) / float(STIMS_PER_FIG)))
figs, response_axs, first_col_axs = [], [], []
psth_axs = defaultdict(list)
for n in range(n_figs):
fig, axs = plt.subplots(
len(expt_grps) + 1, STIMS_PER_FIG, figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
fig.suptitle('All ROIs summary: {}'.format(
'running excluded' if exclude_running else 'running included'))
figs.append(fig)
for expt_grp, grp_axs in zip(expt_grps, axs):
psth_axs[expt_grp].append(grp_axs)
plotting.right_label(grp_axs[-1], expt_grp.label())
response_axs.append(axs[-1, :])
first_col_axs.append(axs[:, 0])
for expt_grp in expt_grps:
psth_axs[expt_grp] = np.hstack(psth_axs[expt_grp])
response_axs = np.hstack(response_axs)
first_col_axs = np.hstack(first_col_axs)
min_psth_y_lim = np.inf
max_psth_y_lim = -np.inf
for expt_grp, roi_filter, color in zip(expt_grps, roi_filters, colors):
for ax, stimulus in it.izip(psth_axs[expt_grp], stimuli):
ia.PSTH(
expt_grp, stimulus, ax=ax, pre_time=pre_time, post_time=post_time,
exclude='running' if exclude_running else None, data=None,
shade_ste=False, plot_mean=True, channel=channel, label=label,
roi_filter=roi_filter, color=color)
ax.set_title(stimulus)
min_psth_y_lim = np.amin([min_psth_y_lim, ax.get_ylim()[0]])
max_psth_y_lim = np.amax([max_psth_y_lim, ax.get_ylim()[1]])
max_bar_y_lim = 0
data_to_save['responses'] = {expt_grp.label(): [] for expt_grp in expt_grps}
for ax, stimulus in it.izip(response_axs, stimuli):
responses = []
for expt_grp, roi_filter, color in zip(expt_grps, roi_filters, colors):
responses.append(ia.response_magnitudes(
expt_grp, stimulus, method='responsiveness', pre_time=pre_time,
post_time=post_time, data=None,
exclude='running' if exclude_running else None,
channel=channel, label=label, roi_filter=roi_filter))
data_to_save['responses'][expt_grp.label()].append(
[stimulus] + ['{:f}'.format(val) for val in responses[-1]])
plotting.grouped_bar(
ax, values=[[np.abs(r)] for r in responses], cluster_labels=[''],
condition_labels=[expt_grp.label() for expt_grp in expt_grps],
bar_colors=colors, scatter_points=True, jitter_x=True, s=20)
max_bar_y_lim = np.amax([max_bar_y_lim, ax.get_ylim()[1]])
ax.tick_params(bottom=False, labelbottom=False)
for ax in set(it.chain(*psth_axs.itervalues())).difference(first_col_axs):
ax.set_xlabel('')
ax.set_ylabel('')
ax.tick_params(labelleft=False, labelbottom=False)
for ax in it.chain(*psth_axs.itervalues()):
ax.set_ylim(min_psth_y_lim, max_psth_y_lim)
for ax in set(response_axs).intersection(first_col_axs):
ax.set_ylabel('Stim response')
for ax in set(response_axs).difference(first_col_axs):
ax.tick_params(labelleft=False)
legend = ax.get_legend()
if legend is not None:
legend.set_visible(False)
for ax in response_axs:
ax.set_ylim(0, max_bar_y_lim)
# for ax in set(fraction_axs).intersection(first_col_axs):
# ax.set_ylabel('Responsive cell fraction')
# for ax in set(fraction_axs).difference(first_col_axs):
# ax.tick_params(labelleft=False)
if len(stimuli) % STIMS_PER_FIG:
extra_axs = len(stimuli) - n_figs * STIMS_PER_FIG
for ax in it.chain(response_axs[extra_axs:], *[
grp_axs[extra_axs:] for grp_axs in psth_axs.itervalues()]):
ax.set_visible(False)
return figs
def plotRoisOverlay(expt, channel='Ch2', label=None, roi_filter=None,
rasterized=False):
"""Generate a figure of the imaging location with all ROIs overlaid"""
figs = []
background_image = expt.returnFinalPrototype(channel=channel)
roiVerts = expt.roiVertices(
channel=channel, label=label, roi_filter=roi_filter)
labels = expt.roi_ids(channel=channel, label=label, roi_filter=roi_filter)
imaging_parameters = expt.imagingParameters()
aspect_ratio = imaging_parameters['pixelsPerLine'] \
/ imaging_parameters['linesPerFrame']
for plane in xrange(background_image.shape[0]):
fig = plt.figure()
ax = fig.add_subplot(111, rasterized=rasterized)
roi_inds = [i for i, v in enumerate(roiVerts) if v[0][0][2] == plane]
# plane_verts = np.array(roiVerts)[roi_inds].tolist()
plane_verts = [roiVerts[x] for x in roi_inds]
twoD_verts = []
for roi in plane_verts:
roi_polys = []
for poly in roi:
roi_polys.append(poly[:, :2])
twoD_verts.append(roi_polys)
plotting.roiDataImageOverlay(
ax, background_image[plane, :, :], twoD_verts, values=None,
vmin=0, vmax=1, labels=np.array(labels)[roi_inds].tolist(),
cax=None, alpha=0.2, aspect=aspect_ratio)
ax.set_title('{}_{}: plane {}'.format(
expt.parent.get('mouseID'), expt.get('startTime'), plane))
figs.append(fig)
return figs
def trial_responses(
exptGrp, stimuli, channel='Ch2', label=None, roi_filter=None,
exclude_running=False, rasterized=False, plot_mean=False,
gray_traces=False, **psth_kwargs):
"""Plots the response to each stim in 'stimuli' for all rois and trials in
'exptGrp'
"""
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return
# Stims labeled 'off' just flip the tail of the responsive distribution
# but are actually the same PSTH as the 'on' version
# No need to plot both
stimuli = [stim for stim in stimuli if 'off' not in stim]
psths = {}
for stimulus in stimuli:
psths[stimulus], rois, x_range = ia.PSTH(
exptGrp, stimulus, channel=channel, label=label, roi_filter=roi_filter,
return_full=True, exclude='running' if exclude_running else None,
**psth_kwargs)
figs, axs, axs_to_label = plotting.layout_subplots(
n_plots=len(rois) * len(stimuli), rows=4, cols=len(stimuli),
polar=False, sharex=False, figsize=(15, 8), rasterized=rasterized)
for fig in figs:
fig.suptitle('Trial Responses: {}'.format(
'running excluded' if exclude_running else 'running included'))
for ax in axs_to_label:
ax.set_ylabel(r'Average $\Delta$F/F')
ax.set_xlabel('Time (s)')
ax_idx = 0
for roi_idx in xrange(len(rois)):
for stimulus in stimuli:
ax = axs[ax_idx]
# If there are no trial psths for this roi, just move along
if psths[stimulus][roi_idx].shape[1] > 0:
if gray_traces:
ax.plot(x_range[roi_idx], psths[stimulus][roi_idx],
color='0.8')
else:
ax.plot(x_range[roi_idx], psths[stimulus][roi_idx])
if plot_mean:
ax.plot(
x_range[roi_idx],
np.nanmean(psths[stimulus][roi_idx], axis=1),
lw=2, color='k')
ax.axvline(0, linestyle='dashed', color='k')
ax.set_xlim(x_range[roi_idx][0], x_range[roi_idx][-1])
ylims = np.round(ax.get_ylim(), 2)
if ylims[1] != 0:
ax.set_yticks([0, ylims[1]])
elif ylims[0] != 0:
ax.set_yticks([ylims[0], 0])
else:
ax.set_yticks([0])
ax_geometry = ax.get_geometry()
# If ax is in top row add a stim title
if ax_geometry[2] <= ax_geometry[1]:
ax.set_title(stimulus)
# If ax is in last column add an roi label
if ax_geometry[2] % ax_geometry[1] == 0:
roi_label = rois[roi_idx][0].get('mouseID') + '\n' + \
rois[roi_idx][1] + '\n' + rois[roi_idx][2]
# Bbox = ax.figbox
# ax.figure.text(Bbox.p1[0] + 0.02,
# (Bbox.p1[1] + Bbox.p0[1]) / 2,
# roi_label, rotation='vertical',
# verticalalignment='center')
plotting.right_label(
ax, roi_label, rotation='vertical',
verticalalignment='center', horizontalalignment='center')
# Remove extra labels
if ax not in axs_to_label:
ax.tick_params(labelbottom=False)
ax_idx += 1
if np.mod(roi_idx, 4) == 3:
yield figs[roi_idx / 4]
def compare_stim_responses(
exptGrp, stimuli, channel='Ch2', label=None, roi_filter=None,
exclude_running=False, rasterized=False, plot_method='scatter',
z_score=True, **kwargs):
"""Plot of each pair of stims in stimuli against each other."""
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return []
figs, axs, _ = plotting.layout_subplots(
comb(len(stimuli), 2), rows=2, cols=4, figsize=(15, 8),
sharex=False, rasterized=rasterized)
rois = {}
means = {}
stds = {}
for stimulus in stimuli:
means[stimulus], stds[stimulus], _, rois[stimulus], _ = \
ia.response_magnitudes(
exptGrp, stimulus, channel=channel, label=label, roi_filter=roi_filter,
return_full=True, z_score=z_score,
exclude='running' if exclude_running else None, **kwargs)
for ax, (stim1, stim2) in zip(axs, it.combinations(stimuli, 2)):
if plot_method == 'ellipse':
raise NotImplemented
means_1 = []
means_2 = []
stds_1 = []
stds_2 = []
all_rois = rois[stim1] + rois[stim2]
for roi in set(all_rois):
if roi in rois[stim1] and roi in rois[stim2]:
idx_1 = rois[stim1].index(roi)
idx_2 = rois[stim2].index(roi)
means_1.append(means[stim1][idx_1])
means_2.append(means[stim2][idx_2])
stds_1.append(stds[stim1][idx_1])
stds_2.append(stds[stim2][idx_2])
max_x = np.nanmax(np.array(means_1) + np.array(stds_1))
x_std = 4 * nanstd(means_1)
max_x = min([max_x, nanmean(means_1) + x_std])
max_y = np.nanmax(np.array(means_2) + np.array(stds_2))
y_std = 4 * nanstd(means_2)
max_y = min([max_y, nanmean(means_2) + y_std])
min_x = np.nanmin(np.array(means_1) - np.array(stds_1))
min_x = max([min_x, nanmean(means_1) - x_std])
min_y = np.nanmin(np.array(means_2) - np.array(stds_2))
min_y = max([min_y, nanmean(means_2) - y_std])
finite_means = np.isfinite(means_1) & np.isfinite(means_2)
if not np.any(finite_means):
continue
plotting.ellipsePlot(ax, means_1, means_2, stds_1, stds_2,
axesCenter=False, print_stats=True)
ax.set_xlim(min_x, max_x)
ax.set_ylim(min_y, max_y)
ax.axvline(0, linestyle=':', color='k')
ax.axhline(0, linestyle=':', color='k')
ax.set_xlabel(stim1)
ax.set_ylabel(stim2)
elif plot_method == 'scatter':
means_1 = []
means_2 = []
all_rois = rois[stim1] + rois[stim2]
for roi in set(all_rois):
if roi in rois[stim1] and roi in rois[stim2]:
idx_1 = rois[stim1].index(roi)
idx_2 = rois[stim2].index(roi)
means_1.append(means[stim1][idx_1])
means_2.append(means[stim2][idx_2])
finite_means = np.isfinite(means_1) & np.isfinite(means_2)
if not np.any(finite_means):
continue
plotting.scatterPlot(
ax, [means_1, means_2], [stim1, stim2], s=1.5,
print_stats=True)
ax.axvline(0, linestyle=':', color='k')
ax.axhline(0, linestyle=':', color='k')
else:
raise ValueError
for fig in figs:
fig.suptitle('Stim response {}comparison: {}'.format(
'z-score ' if z_score else '',
'running excluded' if exclude_running else 'running included'))
return figs
def quantify_multi_responses(
exptGrp, stimuli, method='responsiveness', channel='Ch2', label=None,
roi_filter=None, pre_time=None, post_time=None, rasterized=False,
n_processes=1, n_bootstraps=10000):
"""Quantifies the number of stimuli that each ROI responds to,
plots as a histogram"""
fig, axs = plt.subplots(1, 2, subplot_kw={'rasterized': rasterized},
figsize=(15, 8))
ia.plot_number_of_stims_responsive(
exptGrp, axs[0], stimuli, method=method, pre_time=pre_time,
post_time=post_time, exclude=None, channel=channel, label=label,
roi_filter=roi_filter, n_processes=n_processes,
n_bootstraps=n_bootstraps)
ia.plot_number_of_stims_responsive(
exptGrp, axs[1], stimuli, method=method, pre_time=pre_time,
post_time=post_time, exclude='running', channel=channel, label=label,
roi_filter=roi_filter, n_processes=n_processes,
n_bootstraps=n_bootstraps)
axs[0].set_title('Running included')
axs[1].set_title('Running excluded')
return fig
def response_linearity(
exptGrp, paired_stimuli, channel='Ch2', label=None, roi_filter=None,
exclude_running=False, responsive_method=None, rasterized=False,
plot_method='ellipse', **kwargs):
"""Histogram of response linearities
Calculated as combined_response / (single_response_1 + single_response_2)
Parameters
----------
paired_stimuli : list of paired stimuli to analyze
responsive_method : None, to include all rois, or a method for identifying
stim responsive rois
"""
paired_stimuli = [stim for stim in paired_stimuli if 'Paired' in stim]
if not paired_stimuli:
return []
figs, axs, _ = plotting.layout_subplots(
len(paired_stimuli), rows=2, cols=4, figsize=(15, 8),
sharex=False, rasterized=rasterized)
for stimulus, ax in zip(paired_stimuli, axs):
stims = stimulus.split()[1:]
if responsive_method:
stimulus_filter = ia.identify_stim_responsive_cells(
exptGrp, stimulus=stimulus, method=responsive_method,
channel=channel, label=label, roi_filter=roi_filter,
exclude='running' if exclude_running else None,
**kwargs)
else:
stimulus_filter = roi_filter
psth1, rois_1, x_ranges1 = ia.PSTH(
exptGrp, stims[0], channel=channel, label=label, roi_filter=stimulus_filter,
return_full=True, exclude='running' if exclude_running else None,
**kwargs)
responses_1 = []
for roi_psth, roi_x_range in zip(psth1, x_ranges1):
responses_1.append(nanmean(roi_psth[roi_x_range > 0], axis=0) -
nanmean(roi_psth[roi_x_range < 0], axis=0))
psth2, rois_2, x_ranges2 = ia.PSTH(
exptGrp, stims[1], channel=channel, label=label, roi_filter=stimulus_filter,
return_full=True, exclude='running' if exclude_running else None,
**kwargs)
responses_2 = []
for roi_psth, roi_x_range in zip(psth2, x_ranges2):
responses_2.append(nanmean(roi_psth[roi_x_range > 0], axis=0) -
nanmean(roi_psth[roi_x_range < 0], axis=0))
psth_combo, rois_combo, x_ranges_combo = ia.PSTH(
exptGrp, stimulus, channel=channel, label=label, roi_filter=stimulus_filter,
return_full=True, exclude='running' if exclude_running else None,
**kwargs)
responses_combo = []
for roi_psth, roi_x_range in zip(psth_combo, x_ranges_combo):
responses_combo.append(
nanmean(roi_psth[roi_x_range > 0], axis=0) -
nanmean(roi_psth[roi_x_range < 0], axis=0))
shared_rois = set(rois_1).intersection(rois_2).intersection(rois_combo)
combined_mean = []
combined_std = []
summed_mean = []
summed_std = []
linearity_ratios = []
for roi in shared_rois:
combo = responses_combo[rois_combo.index(roi)]
stim1 = responses_1[rois_1.index(roi)]
stim2 = responses_2[rois_2.index(roi)]
combined_mean.append(nanmean(combo))
combined_std.append(nanstd(combo))
summed_mean.append(nanmean(stim1) + nanmean(stim2))
# Propagate summed std
summed_std.append(
np.sqrt(nanstd(stim1) ** 2 + nanstd(stim2) ** 2))
linearity_ratios.append(combined_mean[-1] / summed_mean[-1])
if np.all(np.isnan(linearity_ratios)):
ax.set_visible(False)
continue
if plot_method == 'hist':
linearity_ratios = [ratio for ratio in linearity_ratios
if not np.isnan(ratio)]
if len(linearity_ratios) == 0:
return []
plotting.histogram(ax, linearity_ratios, bins=10, plot_mean=True)
ax.set_title(stimulus)
ax.set_xlabel('combined / (stim1 + stim2)')
ax.set_ylabel('Number')
elif plot_method == 'ellipse':
plotting.ellipsePlot(
ax, summed_mean, combined_mean, summed_std, combined_std,
axesCenter=False, print_stats=True)
ax.set_title(stimulus)
ax.set_xlabel('stim1 + stim2')
ax.set_ylabel('combined')
combined_mean = np.array(combined_mean)
combined_std = np.array(combined_std)
summed_mean = np.array(summed_mean)
summed_std = np.array(summed_std)
max_x = np.nanmax(summed_mean + summed_std)
x_std = 4 * nanstd(summed_mean)
max_x = min([max_x, nanmean(summed_mean) + x_std])
max_y = np.nanmax(combined_mean + combined_std)
y_std = 4 * nanstd(combined_mean)
max_y = min([max_y, nanmean(combined_mean) + y_std])
min_x = np.nanmin(summed_mean - summed_std)
min_x = max([min_x, nanmean(summed_mean) - x_std])
min_y = np.nanmin(combined_mean - combined_std)
min_y = max([min_y, nanmean(combined_mean) - y_std])
ax.set_xlim(min_x, max_x)
ax.set_ylim(min_y, max_y)
ax.axvline(0, linestyle=':', color='k')
ax.axhline(0, linestyle=':', color='k')
elif plot_method == 'scatter':
plotting.scatterPlot(
ax, [summed_mean, combined_mean],
['stim1 + stim2', 'combined'], s=1, print_stats=True)
ax.axvline(0, linestyle=':', color='k')
ax.axhline(0, linestyle=':', color='k')
ax.set_title(stimulus)
else:
raise ValueError(
'Unrecognized plot method: {}'.format(plot_method))
for fig in figs:
fig.suptitle('Stim response linearity, {}: {}'.format(
'all ROIs' if responsive_method is None else 'responsive ROIs only',
'running excluded' if exclude_running else 'running included'))
return figs
def run_duration_responsiveness(
exptGrp, channel='Ch2', label=None, roi_filter=None, rasterized=False,
method='responsiveness', **psth_kwargs):
"""Create figure comparing the magnitude of running responses versus
duration of running bout.
"""
figs = []
fig, axs = plt.subplots(2, 2, subplot_kw={'rasterized': rasterized},
figsize=(15, 8))
ia.compare_run_response_by_running_duration(
exptGrp, axs[0, 0], run_intervals='running_start',
response_method='responsiveness', plot_method='scatter',
channel=channel, label=label, roi_filter=roi_filter,
responsive_method=method, **psth_kwargs)
ia.compare_run_response_by_running_duration(
exptGrp, axs[0, 1], run_intervals='running_stop',
response_method='responsiveness', plot_method='scatter',
channel=channel, label=label, roi_filter=roi_filter,
responsive_method=method, **psth_kwargs)
# ia.compare_run_response_by_running_duration(
# exptGrp, axs[1, 0], run_intervals='running_stim',
# response_method='responsiveness', plot_method='scatter',
# channel=channel, label=label, roi_filter=roi_filter,
# responsive_method=method, **psth_kwargs)
# ia.compare_run_response_by_running_duration(
# exptGrp, axs[1, 1], run_intervals='running_no_stim',
# response_method='responsiveness', plot_method='scatter',
# channel=channel, label=label, roi_filter=roi_filter,
# responsive_method=method, **psth_kwargs)
# figs.append(fig)
# fig, axs = plt.subplots(2, 2, subplot_kw={'rasterized': rasterized},
# figsize=(15, 8))
ia.compare_run_response_by_running_duration(
exptGrp, axs[1, 0], run_intervals='running_start',
response_method='mean', plot_method='scatter',
channel=channel, label=label, roi_filter=roi_filter,
responsive_method=method, **psth_kwargs)
ia.compare_run_response_by_running_duration(
exptGrp, axs[1, 1], run_intervals='running_stop',
response_method='mean', plot_method='scatter',
channel=channel, label=label, roi_filter=roi_filter,
responsive_method=method, **psth_kwargs)
# ia.compare_run_response_by_running_duration(
# exptGrp, axs[1, 0], run_intervals='running_stim',
# response_method='mean', plot_method='scatter',
# channel=channel, label=label, roi_filter=roi_filter,
# responsive_method=method, **psth_kwargs)
# ia.compare_run_response_by_running_duration(
# exptGrp, axs[1, 1], run_intervals='running_no_stim',
# response_method='mean', plot_method='scatter',
# channel=channel, label=label, roi_filter=roi_filter,
# responsive_method=method, **psth_kwargs)
figs.append(fig)
return figs
def imaging_and_behavior_summary(
exptGrp, channel='Ch2', label=None, roi_filter=None):
"""Creates a summary figure of imaging data and behavior data"""
nTrials = sum([len(expt.findall('trial')) for expt in exptGrp])
figs, axs, _ = plotting.layout_subplots(
nTrials, rows=1, cols=2, figsize=(15, 8), sharex=False)
for ax, trial in it.izip(
axs, it.chain(*[expt.findall('trial') for expt in exptGrp])):
if isinstance(trial.parent, lab.classes.SalienceExperiment):
stim = trial.get('stimulus')
if stim == 'air':
stim = 'airpuff'
stim_time = trial.parent.stimulusTime()
if 'Paired' in stim:
keys = stim.split(' ')[1:] + ['running', 'licking']
else:
keys = [stim, 'running', 'licking']
ap.plot_imaging_and_behavior(
trial, ax, keys=keys, channel=channel, label=label,
roi_filter=roi_filter, include_empty=True)
ax.axvline(stim_time, linestyle='dashed', color='k')
ax.set_xticklabels(ax.get_xticks() - stim_time)
ax.set_title('{}_{}: {}'.format(
trial.parent.parent.get('mouseID'),
trial.parent.get('uniqueLocationKey'), trial.get('time')))
else:
ap.plot_imaging_and_behavior(
trial, ax, channel=channel, label=label, roi_filter=roi_filter,
include_empty=False)
return figs
def response_cdfs(
exptGrp, stimuli, method='responsiveness', pre_time=None,
post_time=None, channel='Ch2', label=None, roi_filter=None,
rasterized=False):
"""Plot cdfs across all rois for each stim in stimuli.
Plots all stims except running/licking, all running/licking stims, and
all stims with running excluded"""
fig, axs = plt.subplots(
1, 3, figsize=(15, 8), subplot_kw={'rasterized': rasterized})
cmap = matplotlib.cm.get_cmap(name='Spectral')
#
# Plot all stims except running/licking
#
axs[0].set_title('All stims (except running/licking)')
stims = [stim for stim in stimuli
if 'running' not in stim and 'licking' not in stim]
colors = [cmap(i) for i in np.linspace(0, 0.9, len(stims))]
for stim, color in zip(stims, colors):
responses = ia.response_magnitudes(
exptGrp, stim, method=method, pre_time=pre_time, post_time=post_time,
channel=channel, label=label, roi_filter=roi_filter,
return_full=False, exclude=None)
non_nan_responses = responses[np.isfinite(responses)]
if len(non_nan_responses):
plotting.cdf(axs[0], non_nan_responses, bins='exact', color=color)
axs[0].legend(stims, loc='lower right')
#
# Plot running/licking stims
#
axs[1].set_title('Running/licking responses')
stims = [stim for stim in stimuli
if 'running' in stim or 'licking' in stim]
colors = [cmap(i) for i in np.linspace(0, 0.9, len(stims))]
for stim, color in zip(stims, colors):
responses = ia.response_magnitudes(
exptGrp, stim, method=method, pre_time=pre_time, post_time=post_time,
channel=channel, label=label, roi_filter=roi_filter,
return_full=False, exclude=None)
non_nan_responses = responses[np.isfinite(responses)]
if len(non_nan_responses):
plotting.cdf(axs[1], non_nan_responses, bins='exact', color=color)
axs[1].legend(stims, loc='lower right')
#
# Plot all stims with running excluded
#
axs[2].set_title('All stims, running excluded')
stims = [stim for stim in stimuli if 'running' not in stim]
colors = [cmap(i) for i in np.linspace(0, 0.9, len(stims))]
for stim, color in zip(stims, colors):
responses = ia.response_magnitudes(
exptGrp, stim, method=method, pre_time=pre_time, post_time=post_time,
channel=channel, label=label, roi_filter=roi_filter,
return_full=False, exclude='running')
non_nan_responses = responses[np.isfinite(responses)]
if len(non_nan_responses):
plotting.cdf(axs[2], non_nan_responses, bins='exact', color=color)
axs[2].legend(stims, loc='lower right')
for ax in axs:
ax.set_xlabel('Responsiveness')
return fig
def paired_stims_response_heatmaps(
exptGrp, stimuli, exclude_running=False, rasterized=False,
**response_kwargs):
"""Plot heatmaps of response magnitude of paired stims versus
single stims
"""
paired_stims = [stim for stim in stimuli if 'Paired' in stim]
fig, axs = plt.subplots(
1, len(paired_stims), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(wspace=0.5)
for ax, paired_stim in it.izip(axs, paired_stims):
stims_in_pair = paired_stim.split()[1:]
stims_to_plot = [paired_stim] + stims_in_pair + \
[stim for stim in exptGrp.stimuli()
if 'Paired' not in stim and stim not in stims_in_pair]
ap.stim_response_heatmap(
exptGrp, ax, stims_to_plot, sort_by=paired_stim,
exclude='running' if exclude_running else None,
aspect_ratio=0.2, **response_kwargs)
ax.axvline(0.5, linewidth=3, color='k')
ax.axvline(2.5, linewidth=3, color='k')
for label in ax.get_yticklabels():
label.set_fontsize(7)
x_labels = []
for label in ax.get_xticklabels():
label.set_fontsize(5)
x_labels.append(''.join([s[0] for s in label.get_text().split()]))
ax.set_xticklabels(x_labels)
title = fig.suptitle(
'Paired stim heatmap, sort by paired stim, running {}'.format(
'excluded' if exclude_running else 'included'))
title.set_fontsize(7)
yield fig
fig, axs = plt.subplots(
1, len(paired_stims), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(wspace=0.5)
for ax, paired_stim in it.izip(axs, paired_stims):
stims_in_pair = paired_stim.split()[1:]
stims_to_plot = [paired_stim] + stims_in_pair + \
[stim for stim in exptGrp.stimuli()
if 'Paired' not in stim and stim not in stims_in_pair]
ap.stim_response_heatmap(
exptGrp, ax, stims_to_plot, sort_by=stims_in_pair,
exclude='running' if exclude_running else None,
aspect_ratio=0.2, **response_kwargs)
ax.axvline(0.5, linewidth=3, color='k')
ax.axvline(2.5, linewidth=3, color='k')
for label in ax.get_yticklabels():
label.set_fontsize(7)
x_labels = []
for label in ax.get_xticklabels():
label.set_fontsize(5)
x_labels.append(''.join([s[0] for s in label.get_text().split()]))
ax.set_xticklabels(x_labels)
title = fig.suptitle(
'Paired stim heatmap, sort by single stims in pair, running {}'.format(
'excluded' if exclude_running else 'included'))
title.set_fontsize(7)
yield fig
def compare_bouton_response_figure(
exptGrp, stimuli, plot_method='cdf', save_data=False, rasterized=False,
**response_kwargs):
"""Figure to compare different types of boutons"""
fig, axs = plt.subplots(2, 3, subplot_kw={'rasterized': rasterized})
data_to_save = {}
data_to_save['angle'] = ap.compare_bouton_responses(
exptGrp, axs[0, 0], stimuli, comp_method='angle', plot_method=plot_method,
**response_kwargs)
data_to_save['abs angle'] = ap.compare_bouton_responses(
exptGrp, axs[1, 0], stimuli, comp_method='abs angle', plot_method=plot_method,
**response_kwargs)
data_to_save['corr'] = ap.compare_bouton_responses(
exptGrp, axs[0, 1], stimuli, comp_method='corr', plot_method=plot_method,
**response_kwargs)
data_to_save['abs corr'] = ap.compare_bouton_responses(
exptGrp, axs[1, 1], stimuli, comp_method='abs corr', plot_method=plot_method,
**response_kwargs)
data_to_save['mean diff'] = ap.compare_bouton_responses(
exptGrp, axs[0, 2], stimuli, comp_method='mean diff', plot_method=plot_method,
**response_kwargs)
for line_idx, line in enumerate(axs[0, 2].lines):
axs[1, 2].axhline(
line_idx, color=line.get_color(), label=line.get_label())
axs[1, 2].set_ylim(-1, len(axs[0, 2].lines))
axs[1, 2].tick_params(labelbottom=False, labelleft=False, bottom=False,
left=False, top=False, right=False)
axs[1, 2].legend()
if save_data:
misc.save_data(data_to_save, fig=fig, label='compare_bouton_responses',
method=save_data)
return fig
def hidden_rewards_learning_summary(
exptGrps, save_data=False, rasterized=False, groupby=None, plotby=None,
orderby=None, colors=None, label_every_n=1):
"""Generates a summary figure of hidden reward analysis plots"""
if groupby is None:
groupby = [['expt', 'condition_day_session']]
if plotby is None:
plotby = ['condition_day_session']
data_to_save = {}
figs = []
fig, axs = plt.subplots(
2, 4, figsize=(15, 8), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
data_to_save['time_per_lap'] = plot_metric(
axs[0, 0], exptGrps, metric_fn=eg.time_per_lap,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Time per lap (sec)',
label_every_n=label_every_n, label_groupby=False)
data_to_save['fraction_rewarded_laps'] = plot_metric(
axs[0, 1], exptGrps, metric_fn=ra.fraction_of_laps_rewarded,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Fraction of laps rewarded',
label_every_n=label_every_n, label_groupby=False)
data_to_save['rewards_per_lap'] = plot_metric(
axs[0, 2], exptGrps, metric_fn=eg.stims_per_lap,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Number of rewards per lap',
activity_kwargs={'stimulus': 'water'},
label_every_n=label_every_n, label_groupby=False)
data_to_save['n_laps'] = plot_metric(
axs[0, 3], exptGrps, metric_fn=eg.number_of_laps,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Number of laps',
label_every_n=label_every_n, label_groupby=False)
data_to_save['water_rate'] = plot_metric(
axs[1, 0], exptGrps, metric_fn=ra.rate_of_water_obtained,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Rate of water obtained (ms/min)',
label_every_n=label_every_n, label_groupby=False)
data_to_save['rewarded_lick_duration'] = plot_metric(
axs[1, 1], exptGrps, metric_fn=eg.lick_bout_duration,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
activity_kwargs={'bouts_to_include': 'rewarded', 'threshold': 0.5},
activity_label='Duration of rewarded lick bouts (s)',
plot_method='line', label_every_n=label_every_n, label_groupby=False)
data_to_save['n_licks'] = plot_metric(
axs[1, 2], exptGrps, metric_fn=eg.behavior_dataframe,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
activity_kwargs={'key': 'licking'}, activity_label='Number of licks',
plot_method='line', agg_fn=np.sum, label_every_n=label_every_n,
label_groupby=False)
fig.suptitle('groupby = {}'.format(groupby))
figs.append(fig)
if save_data:
misc.save_data(data_to_save, fig=figs, method=save_data,
label='hidden_rewards_behavior_1')
data_to_save = {}
fig, axs = plt.subplots(
2, 4, figsize=(15, 8), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
data_to_save['rewarded_lick_intervals'] = plot_metric(
axs[0, 0], exptGrps, metric_fn=ra.fraction_rewarded_lick_intervals,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Fraction of lick intervals rewarded', colors=colors,
activity_kwargs={'threshold': 0.5}, label_every_n=label_every_n,
label_groupby=False)
data_to_save['licks_in_rewarded_intervals'] = plot_metric(
axs[1, 0], exptGrps,
metric_fn=ra.fraction_licks_in_rewarded_intervals,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Fraction of licks in rewarded intervals',
colors=colors, activity_kwargs={'threshold': 0.5},
label_every_n=label_every_n, label_groupby=False)
data_to_save['licks_in_reward_zone'] = plot_metric(
axs[0, 1], exptGrps, metric_fn=ra.fraction_licks_in_reward_zone,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Fraction of licks in reward zone', colors=colors,
label_every_n=label_every_n, label_groupby=False)
data_to_save['licks_near_rewards'] = plot_metric(
axs[1, 1], exptGrps, metric_fn=ra.fraction_licks_near_rewards,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Fraction of licks near rewards', colors=colors,
label_every_n=label_every_n, label_groupby=False)
data_to_save['licking_spatial_information'] = plot_metric(
axs[0, 2], exptGrps, metric_fn=ra.licking_spatial_information,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Licking spatial information (bits/sec)', colors=colors,
label_every_n=label_every_n, label_groupby=False)
# Licking circular variance
data_to_save['lick_to_reward_distance'] = plot_metric(
axs[0, 3], exptGrps, metric_fn=ra.lick_to_reward_distance,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Lick distance to reward (norm units)', colors=colors,
label_every_n=label_every_n, label_groupby=False)
data_to_save['licks_outside_reward_vicinity'] = plot_metric(
axs[1, 2], exptGrps, metric_fn=ra.licks_outside_reward_vicinity,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Fraction of licks outside reward vicinity', colors=colors,
label_every_n=label_every_n, label_groupby=False)
# data_to_save['anticipatory_licks'] = plot_metric(
# axs[1, 3], exptGrps, metric_fn=ra.anticipatory_licking,
# groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
# activity_label='Anticipatory licking', colors=colors,
# label_every_n=label_every_n, label_groupby=False)
data_to_save['anticipatory_lick_fraction'] = plot_metric(
axs[1, 3], exptGrps, metric_fn=ra.fraction_licks_near_rewards,
groupby=groupby, plotby=plotby, orderby=orderby, plot_method='line',
activity_label='Anticipatory lick fraction', colors=colors,
label_every_n=label_every_n, label_groupby=False,
activity_kwargs={'pre_window_cm': 5, 'exclude_reward': True})
fig.suptitle('groupby = {}'.format(groupby))
figs.append(fig)
if save_data:
misc.save_data(data_to_save, fig=figs, method=save_data,
label='hidden_rewards_behavior_2')
return figs
def hidden_reward_behavior_control_summary(
exptGrps, save_data=False, rasterized=False, groupby=None, plotby=None,
orderby=None, colors=None, label_every_n=1):
"""Generate a control figure for hidden rewards behavior experiments."""
if groupby is None:
groupby = [['expt', 'condition_day_session']]
if plotby is None:
plotby = ['condition_day_session']
data_to_save = {}
fig, axs = plt.subplots(
2, 2, figsize=(15, 8), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
# Grouping by expt, trial, or mouse defeats the purpose of n_sessions plot
n_ses_groupby = []
for group in groupby:
new_groupby = filter(
lambda x: x not in ['expt', 'trial', 'mouseID'], group)
if len(new_groupby):
n_ses_groupby.append(new_groupby)
if not len(n_ses_groupby):
n_ses_groupby = None
data_to_save['n_sessions'] = plot_metric(
axs[0, 0], exptGrps, metric_fn=eg.dataframe,
groupby=n_ses_groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Total number of sessions',
label_every_n=label_every_n, agg_fn=np.sum)
data_to_save['n_laps'] = plot_metric(
axs[0, 1], exptGrps, metric_fn=eg.number_of_laps,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Number of laps',
label_every_n=label_every_n)
data_to_save['reward_windows_per_lap'] = plot_metric(
axs[1, 0], exptGrps, metric_fn=eg.stims_per_lap,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Number of reward windows per lap',
activity_kwargs={'stimulus': 'reward'},
label_every_n=label_every_n)
data_to_save['reward_position'] = plot_metric(
axs[1, 1], exptGrps, metric_fn=eg.stim_position,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_label='Mean reward location',
activity_kwargs={'stimulus': 'reward', 'normalized': False},
label_every_n=label_every_n)
try:
expected_positions = [expt.rewardPositions(units=None)
for exptGrp in exptGrps for expt in exptGrp]
expected_positions = set(it.chain(*expected_positions))
except AttributeError:
pass
else:
for position in expected_positions:
axs[1, 1].axhline(position, color='red')
if save_data:
misc.save_data(data_to_save, fig=fig, method=save_data,
label='hidden_rewards_control')
return fig
def hidden_rewards_move_rewards_learning(
exptGrps, groupby=None, plotby=None, orderby=None, colors=None,
label_every_n=1, rasterized=False, save_data=False,
rewards='combined', by_condition=False):
if groupby is None:
groupby = [['expt', 'condition_day_session']]
if plotby is None:
plotby = ['condition_day_session']
data_to_save = {}
if rewards == 'combined':
reward_positions = set()
for exptGrp in exptGrps:
if by_condition:
conditions, _ = exptGrp.condition_label(by_mouse=True)
reward_positions = reward_positions.union(conditions.values())
else:
for expt in exptGrp:
for pos in expt.rewardPositions(units=None):
reward_positions.add(pos)
reward_positions = sorted(reward_positions)
elif rewards == 'separate':
reward_positions = {}
for exptGrp in exptGrps:
reward_positions[exptGrp] = set()
if by_condition:
conditions, _ = exptGrp.condition_label(by_mouse=True)
reward_positions = reward_positions[exptGrp].union(
conditions.values())
else:
for expt in exptGrp:
for pos in expt.rewardPositions(units=None):
reward_positions[exptGrp].add(pos)
reward_positions[exptGrp] = sorted(reward_positions[exptGrp])
if colors is None:
if rewards == 'combined':
colors = sns.color_palette(
"Paired", len(exptGrps) * len(reward_positions))
if rewards == 'separate':
colors = sns.color_palette(
"Paired", len(exptGrps) * sum(map(len, reward_positions)))
else:
# Lightest is too light, so add an extra color that we'll ignore
colors = [sns.light_palette(
color, len(reward_positions) + 1,
reverse=True)[:len(reward_positions)] for color in colors]
colors = list(it.chain(*colors))
new_exptGrps = []
activity_kwargs = []
for exptGrp in exptGrps:
if rewards == 'combined':
pos_iter = reward_positions
elif rewards == 'separate':
pos_iter = reward_positions[exptGrp]
for pos in pos_iter:
new_exptGrp = lab.classes.HiddenRewardExperimentGroup(exptGrp)
if by_condition:
new_exptGrp.label(exptGrp.label() + '_{}'.format(pos))
activity_kwargs.append({'rewardPositions': pos})
else:
new_exptGrp.label(exptGrp.label() + '_{:0.1f}'.format(pos))
activity_kwargs.append({'rewardPositions': [pos]})
new_exptGrps.append(new_exptGrp)
fig, axs = plt.subplots(
1, 3, figsize=(15, 8), subplot_kw={'rasterized': rasterized},
squeeze=False)
fig.subplots_adjust(hspace=0.3)
data_to_save['lick_to_reward_distance'] = plot_metric(
axs[0, 0], new_exptGrps, metric_fn=ra.lick_to_reward_distance,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_kwargs=activity_kwargs,
activity_label='lick distance to reward (norm units)',
label_every_n=label_every_n, label_groupby=False)
data_to_save['licks_near_rewards'] = plot_metric(
axs[0, 1], new_exptGrps, metric_fn=ra.fraction_licks_near_rewards,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_kwargs=activity_kwargs,
activity_label='fraction of licks near rewards',
label_every_n=label_every_n, label_groupby=False)
data_to_save['fraction_laps_licking'] = plot_metric(
axs[0, 2], new_exptGrps,
metric_fn=ra.fraction_of_laps_with_licking_near_reward,
groupby=groupby, plotby=plotby, orderby=orderby, colors=colors,
plot_method='line', activity_kwargs=activity_kwargs,
activity_label='fraction of laps w/ licks near rewards',
label_every_n=label_every_n, label_groupby=False)
fig.suptitle('groupby = {}'.format(groupby))
if save_data:
misc.save_data(data_to_save, fig=fig, method=save_data,
label='hidden_rewards_behavior')
return fig
def stim_response_summary(
expt_grp, stimuli, pre_time=None, post_time=None, channel='Ch2',
label=None, roi_filter=None):
fig, axs = plt.subplots(2, len(stimuli), figsize=(15, 8))
for stim, ax_pair in zip(stimuli, axs.T):
ia.PSTH(
expt_grp, stim, ax=ax_pair[0], pre_time=pre_time, post_time=post_time,
shade_ste=False, plot_mean=True, channel=channel, label=label,
roi_filter=roi_filter, gray_traces=True)
ia.PSTH(
expt_grp, stim, ax=ax_pair[1], pre_time=pre_time, post_time=post_time,
shade_ste='sem', plot_mean=True, channel=channel, label=label,
roi_filter=roi_filter)
ax_pair[0].set_title(stim)
ax_pair[0].set_xlabel('')
ax_pair[0].tick_params(axis='x', labelbottom=False)
min_y, max_y = np.inf, -np.inf
for ax in axs[0, :]:
min_y = np.amin([min_y, ax.get_ylim()[0]])
max_y = np.amax([max_y, ax.get_ylim()[1]])
for ax in axs[0, :]:
ax.set_ylim(min_y, max_y)
min_y, max_y = np.inf, -np.inf
for ax in axs[1, :]:
min_y = np.amin([min_y, ax.get_ylim()[0]])
max_y = np.amax([max_y, ax.get_ylim()[1]])
for ax in axs[1, :]:
ax.set_ylim(min_y, max_y)
for ax_row in axs[:, 1:]:
for ax in ax_row:
ax.set_ylabel('')
return fig
def licktogram_summary(expt_grps, rasterized=False, polar=False):
"""Plots licktograms for every condition/day by mouse"""
dataframes = [expt_grp.dataframe(
expt_grp, include_columns=['mouseID', 'expt', 'condition', 'session'])
for expt_grp in expt_grps]
dataframe = pd.concat(dataframes)
mouse_grp_dict = {
mouse: expt_grp.label() for expt_grp in expt_grps for mouse in
set(expt.parent.get('mouseID') for expt in expt_grp)}
fig_dict = {}
for mouse_id, df in dataframe.groupby('mouseID'):
n_rows = len(set(df['condition']))
n_cols = df['session'].max() + 1
fig, axs = plt.subplots(
n_rows, n_cols, figsize=(15, 8), sharey=not polar,
subplot_kw={'rasterized': rasterized, 'polar': polar},
squeeze=False)
for c_idx, condition in enumerate(sorted(set(df['condition']))):
for session in range(n_cols):
df_slice = df[(df['condition'] == condition) &
(df['session'] == session)]
if len(df_slice) == 1:
expt = df_slice['expt'].iloc[0]
if polar:
expt.polar_lick_plot(ax=axs[c_idx, session])
else:
expt.licktogram(
ax=axs[c_idx, session], plot_belt=False)
else:
axs[c_idx, session].set_visible(False)
for ax, condition in zip(axs[:, -1], sorted(set(df['condition']))):
plotting.right_label(ax, condition)
for ax, session in zip(axs[0, :], range(1, n_cols + 1)):
ax.set_title('Session {}'.format(session))
for ax in axs[:, 1:].flat:
ax.set_ylabel('')
for ax in axs[1:, :].flat:
ax.set_title('')
for ax in axs[:-1, :].flat:
ax.set_xlabel('')
fig.suptitle('{}: {}'.format(mouse_grp_dict[mouse_id], mouse_id))
fig_dict[mouse_id] = fig
return [fig_dict[mouse] for mouse in sorted(fig_dict.keys())]
def behavior_cross_correlation(
expt_grps, roi_filters, behavior_key, channel='Ch2', label=None,
rasterized=False, max_lag=10, thresh=0.5, colors=None):
if colors is None:
colors = sns.color_palette()
fig, axs = plt.subplots(
3, len(expt_grps) + 1, squeeze=False,
subplot_kw={'rasterized': rasterized}, figsize=(15, 8))
fig.suptitle('Imaging-behavior cross-correlation: {}'.format(behavior_key))
corrs = {}
zero_lag, peak_offset = [], []
for grp_axs, color, expt_grp, roi_filter in zip(
axs.T, colors, expt_grps, roi_filters):
corr = sa.xcorr_imaging_behavior(
expt_grp, behavior_key, max_lag=max_lag, thresh=thresh,
return_full=False, channel=channel, label=label,
roi_filter=roi_filter)
assert 0. in corr.index
corrs[expt_grp] = corr
zero_lag.append([np.array(corr[corr.index == 0])[0]])
peak_offset.append([np.array(
[corr.index[i] for i in np.argmax(
np.abs(np.array(corr)), axis=0)])])
light_color = sns.light_palette(color)[1]
grp_axs[0].plot(corr.index, corr, color=light_color)
grp_axs[0].plot(corr.index, corr.mean(1), color=color)
grp_axs[0].set_xlim(corr.index[0], corr.index[-1])
grp_axs[0].set_title(expt_grp.label())
grp_axs[0].set_xlabel('Lag (s)')
grp_axs[0].set_ylabel('Cross-correlation')
plotting.histogram(
grp_axs[1], zero_lag[-1][0], bins=10,
range=(-1, 1), color=color, normed=False,
plot_mean=True, label=None, orientation='vertical', filled=True,
mean_kwargs=None)
grp_axs[1].set_xlabel('zero-lag cross-correlation')
grp_axs[1].set_ylabel('ROIs')
plotting.histogram(
grp_axs[2], peak_offset[-1][0], bins=10,
range=(-max_lag, max_lag), color=color, normed=False,
plot_mean=True, label=None, orientation='vertical', filled=True,
mean_kwargs=None)
grp_axs[2].set_xlabel('Time to peak (s)')
grp_axs[2].set_ylabel('ROIs')
#
# Directly compare
#
for expt_grp, color in zip(expt_grps, colors):
corr = corrs[expt_grp]
axs[0, -1].plot(
corr.index, corr.mean(1), color=color, label=expt_grp.label())
axs[0, -1].fill_between(
corr.index, corr.mean(1) - corr.sem(1), corr.mean(1) + corr.sem(1),
color=color, alpha=0.5)
axs[0, -1].set_xlim(corr.index[0], corr.index[-1])
axs[0, -1].set_xlabel('Lag (s)')
axs[0, -1].set_ylabel('Cross-correlation')
min_y, max_y = np.inf, - np.inf
for ax in axs[0, :]:
min_y = min(min_y, ax.get_ylim()[0])
max_y = max(max_y, ax.get_ylim()[1])
for ax in axs[0, :]:
ax.set_ylim(min_y, max_y)
axs[0, -1].legend(frameon=False, loc='best')
plotting.grouped_bar(
axs[1, -1], values=zero_lag, cluster_labels=[''],
condition_labels=[expt_grp.label() for expt_grp in expt_grps],
bar_colors=colors, scatter_points=True, jitter_x=True, s=20)
axs[1, -1].set_ylabel('zero-lag cross-correlation')
plotting.grouped_bar(
axs[2, -1], values=peak_offset, cluster_labels=[''],
condition_labels=[expt_grp.label() for expt_grp in expt_grps],
bar_colors=colors, scatter_points=True, jitter_x=True, s=20)
axs[2, -1].set_ylabel('Time to peak (s)')
return fig
def plotControlSummary(
exptGrps, roi_filters=None, channel='Ch2', label=None,
rasterized=False, groupby=None, plotby=None, **plot_kwargs):
"""Plot a series of potentially control analysis, looking at similarity of
data over time.
"""
fig, axs = plt.subplots(
2, 3, figsize=(15, 8), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
base_kwargs = {'channel': channel, 'label': label}
activity_kwargs = base_kwargs.copy()
activity_kwargs.update({'stat': 'mean'})
plot_metric(
ax=axs[0, 0], exptGrps=exptGrps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method='line',
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean dF/F", **plot_kwargs)
activity_kwargs = base_kwargs.copy()
activity_kwargs.update({'stat': 'amplitude'})
plot_metric(
ax=axs[0, 1], exptGrps=exptGrps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method='line',
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean transient amplitude", **plot_kwargs)
activity_kwargs = base_kwargs.copy()
activity_kwargs.update({'stat': 'duration'})
plot_metric(
ax=axs[1, 0], exptGrps=exptGrps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method='line',
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean transient duration", **plot_kwargs)
activity_kwargs = base_kwargs.copy()
activity_kwargs.update({'stat': 'frequency'})
plot_metric(
ax=axs[1, 1], exptGrps=exptGrps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method='line',
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean transient frequency", **plot_kwargs)
activity_kwargs = base_kwargs.copy()
plot_metric(
ax=axs[0, 2], exptGrps=exptGrps, roi_filters=roi_filters,
metric_fn=ia.trace_sigma, plot_method='line',
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label='Trace sigma', **plot_kwargs)
activity_kwargs = base_kwargs.copy()
plot_metric(
ax=axs[1, 2], exptGrps=exptGrps, roi_filters=roi_filters,
metric_fn=ia.mean_fluorescence, plot_method='line',
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label='Mean raw fluorescence', **plot_kwargs)
return fig
def plot_calcium_dynamics_summary(
expt_grps, roi_filters=None, channel='Ch2', label=None,
rasterized=False, groupby=None, plotby=None, plot_method='cdf',
**plot_kwargs):
"""A set of control plots designed to compare baseline calcium properties
between genotypes.
"""
fig, axs = plt.subplots(
2, 3, figsize=(15, 8), subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
# Trans psth
# base_kwargs = {'channel': channel, 'label': label}
base_kwargs = []
for expt_grp in expt_grps:
grp_kwargs = {}
try:
grp_kwargs['channel'] = expt_grp.args['channel']
except KeyError:
grp_kwargs['channel'] = channel
try:
grp_kwargs['label'] = expt_grp.args['imaging_label']
except KeyError:
grp_kwargs['label'] = label
activity_kwargs = [dict(bkw.items() + [('stat', 'amplitude')])
for bkw in base_kwargs]
plot_metric(
ax=axs[0, 1], exptGrps=expt_grps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method=plot_method,
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean transient amplitude", **plot_kwargs)
activity_kwargs = [dict(bkw.items() + [('stat', 'duration')])
for bkw in base_kwargs]
plot_metric(
ax=axs[1, 0], exptGrps=expt_grps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method=plot_method,
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean transient duration", **plot_kwargs)
activity_kwargs = [dict(bkw.items() + [('stat', 'frequency')])
for bkw in base_kwargs]
plot_metric(
ax=axs[1, 1], exptGrps=expt_grps, roi_filters=roi_filters,
metric_fn=ia.population_activity, plot_method=plot_method,
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label="Mean transient frequency", **plot_kwargs)
activity_kwargs = base_kwargs
plot_metric(
ax=axs[0, 2], exptGrps=expt_grps, roi_filters=roi_filters,
metric_fn=ia.trace_sigma, plot_method=plot_method,
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label='Trace sigma', **plot_kwargs)
activity_kwargs = base_kwargs
plot_metric(
ax=axs[1, 2], exptGrps=expt_grps, roi_filters=roi_filters,
metric_fn=ia.mean_fluorescence, plot_method=plot_method,
groupby=groupby, plotby=plotby, activity_kwargs=activity_kwargs,
activity_label='Mean raw fluorescence', **plot_kwargs)
return fig
def transient_summary(
expt_grps, plot_method, intervals='running', roi_filters=None,
groupby=None, plotby=None, label_every_n=1, save_data=False,
rasterized=False, interval_kwargs=None, channel='Ch2', label=None,
**plot_kwargs):
"""Generate a summary plot of place field transient statistics."""
if interval_kwargs is None:
interval_kwargs = {}
if roi_filters is None:
roi_filters = [None] * len(expt_grps)
if intervals == 'running':
kwargs = {}
kwargs.update(interval_kwargs)
in_intervals = [inter.running_intervals(
expt_grp, **kwargs) for expt_grp in expt_grps]
out_intervals = [~ints for ints in in_intervals]
elif intervals == 'place field':
kwargs = {}
kwargs.update(interval_kwargs)
in_intervals = [inter.place_fields(
expt_grp, roi_filter=roi_filter, **kwargs) for
expt_grp, roi_filter in zip(expt_grps, roi_filters)]
out_intervals = [~ints for ints in in_intervals]
elif intervals == 'reward':
kwargs = {'nearness': 0.1}
kwargs.update(interval_kwargs)
in_intervals = [inter.near_rewards(
expt_grp, **kwargs) for expt_grp in expt_grps]
out_intervals = [~ints for ints in in_intervals]
else:
raise ValueError("Unrecognized value for 'intervals' argument")
data_to_save = {}
fig, axs = plt.subplots(
3, 5, figsize=(15, 8), subplot_kw={'rasterized': rasterized},
sharey='col')
fig.subplots_adjust(hspace=0.3)
activity_kwargs = {'stat': 'amplitude', 'interval': None, 'channel': channel, 'label': label}
data_to_save['amplitude_all'] = plot_metric(
axs[0, 0], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
axs[0, 0].set_title('amplitude')
activity_kwargs = [
{'stat': 'amplitude', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in in_intervals]
data_to_save['amplitude_in'] = plot_metric(
axs[1, 0], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = [
{'stat': 'amplitude', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in out_intervals]
data_to_save['amplitude_out'] = plot_metric(
axs[2, 0], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = {'stat': 'duration', 'interval': None, 'channel': channel, 'label': label}
data_to_save['duration_all'] = plot_metric(
axs[0, 1], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
axs[0, 1].set_title('duration')
activity_kwargs = [
{'stat': 'duration', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in in_intervals]
data_to_save['duration_in'] = plot_metric(
axs[1, 1], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = [
{'stat': 'duration', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in out_intervals]
data_to_save['duration_out'] = plot_metric(
axs[2, 1], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = {'stat': 'responseMagnitude', 'interval': None, 'channel': channel, 'label': label}
data_to_save['magnitude_all'] = plot_metric(
axs[0, 2], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
axs[0, 2].set_title('responseMagnitude')
activity_kwargs = [
{'stat': 'responseMagnitude', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in in_intervals]
data_to_save['magnitude_in'] = plot_metric(
axs[1, 2], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = [
{'stat': 'responseMagnitude', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in out_intervals]
data_to_save['magnitude_out'] = plot_metric(
axs[2, 2], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = {'stat': 'norm transient auc2', 'interval': None, 'channel': channel, 'label': label}
data_to_save['auc_all'] = plot_metric(
axs[0, 3], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
axs[0, 3].set_title('norm transient auc2')
activity_kwargs = [
{'stat': 'norm transient auc2', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in in_intervals]
data_to_save['auc_in'] = plot_metric(
axs[1, 3], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = [
{'stat': 'norm transient auc2', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in out_intervals]
data_to_save['auc_out'] = plot_metric(
axs[2, 3], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = {'stat': 'frequency', 'interval': None, 'channel': channel, 'label': label}
data_to_save['frequency_all'] = plot_metric(
axs[0, 4], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
axs[0, 4].set_title('frequency')
activity_kwargs = [
{'stat': 'frequency', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in in_intervals]
data_to_save['frequency_in'] = plot_metric(
axs[1, 4], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
activity_kwargs = [
{'stat': 'frequency', 'interval': grp_interval, 'channel': channel, 'label': label}
for grp_interval in out_intervals]
data_to_save['frequency_out'] = plot_metric(
axs[2, 4], expt_grps, metric_fn=ia.population_activity_new,
plot_method=plot_method, roi_filters=roi_filters, groupby=groupby,
plotby=plotby, activity_kwargs=activity_kwargs, activity_label='',
label_every_n=label_every_n, **plot_kwargs)
# Remove extra labels
for ax in axs[:2, :].flat:
ax.set_xlabel('')
for ax in axs[:, 1:].flat:
ax.set_ylabel('')
for ax in axs[1:, :].flat:
ax.set_title('')
plotting.right_label(axs[0, -1], 'all trans')
plotting.right_label(axs[1, -1], 'trans in')
plotting.right_label(axs[2, -1], 'trans out')
fig.suptitle('Activity by {}\ngroupby={}'.format(intervals, groupby))
if save_data:
misc.save_data(data_to_save, fig=fig, label='transient_summary',
method=save_data)
return fig
def thresholded_metric_vs_metric_figure(
exptGrps, x_metric, y_metric, filter_metric, thresholds, roi_filters=None,
x_metric_kwargs=None, y_metric_kwargs=None, filter_metric_kwargs=None,
xlabel=None, ylabel=None, plot_method='scatter', groupby=None,
colorby=None, filter_on=('roi',), title='', save_data=None, filter_fn=None,
**plot_kwargs):
fig, axs = plt.subplots(3, len(thresholds), figsize=(15, 8))
data_to_save = {}
if xlabel is None:
xlabel = 'Metric 1'
if ylabel is None:
ylabel = 'Metric 2'
filter_fns = [misc.df_filter_intersection([None, filter_fn]),
misc.df_filter_intersection([lambda df: df['filter_metric_value'] < threshold, filter_fn]),
misc.df_filter_intersection([lambda df: df['filter_metric_value'] > threshold, filter_fn])]
filter_labels = ['all', 'less_than', 'greater_than']
for col, threshold in enumerate(thresholds):
for row, filter_fn, filter_label in zip(
it.count(), filter_fns, filter_labels):
label = '{}_{}'.format(filter_label, threshold)
data_to_save[label] = plot_paired_metrics(
exptGrps, roi_filters=roi_filters, ax=axs[row, col],
first_metric_fn=x_metric, second_metric_fn=y_metric,
first_metric_kwargs=x_metric_kwargs,
second_metric_kwargs=y_metric_kwargs,
first_metric_label=xlabel,
second_metric_label=ylabel,
plot_method=plot_method,
groupby=groupby,
colorby=colorby,
filter_metric_fn=filter_metric,
filter_metric_merge_on=filter_on,
filter_metric_fn_kwargs=filter_metric_kwargs,
filter_fn=filter_fn, **plot_kwargs)
axs[0, col].set_title('Threshold = {}'.format(threshold))
for ax, label in zip(axs[:, -1], filter_labels):
plotting.right_label(ax, label)
for ax in axs[:, 1:].flat:
ax.set_ylabel('')
for ax in axs[:-1, :].flat:
ax.set_xlabel('')
fig.suptitle(title)
if save_data:
misc.save_data(data_to_save, fig=fig,
label='thresholded_metric_vs_metric', method=save_data)
return fig
def hidden_rewards_number_of_licks(
expt_grps, rasterized=False, groupby=None, plotby=None,
label_every_n=1, **plot_kwargs):
"""Plots the total number of licks in vs out of reward per mouse"""
if groupby is None:
groupby = [['expt', 'condition_day_session']]
if plotby is None:
plotby = ['condition_day_session']
mice = {}
max_mice = -1
for expt_grp in expt_grps:
mice[expt_grp] = {expt.parent for expt in expt_grp}
max_mice = max(max_mice, len(mice[expt_grp]))
fig, axs = plt.subplots(
len(expt_grps), max_mice, figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
for expt_grp, grp_axs in zip(expt_grps, axs):
for mouse, ax in zip(sorted(mice[expt_grp]), grp_axs):
mouse_expt_grp = expt_grp.subGroup(
[expt for expt in expt_grp if expt.parent == mouse],
label='near')
colors = color_cycle()
plot_metric(
ax, [mouse_expt_grp],
metric_fn=ra.number_licks_near_rewards,
plot_method='line', groupby=groupby, plotby=plotby,
label_every_n=label_every_n, colors=[colors.next()],
activity_label='Number of licks', **plot_kwargs)
mouse_expt_grp.label('away')
plot_metric(
ax, [mouse_expt_grp],
metric_fn=ra.number_licks_away_rewards,
plot_method='line', groupby=groupby, plotby=plotby,
label_every_n=label_every_n, colors=[colors.next()],
activity_label='Number of licks', **plot_kwargs)
ax.set_title(mouse.get('mouseID'))
for ax in axs[:, 1:].flat:
ax.set_ylabel('')
ax.tick_params(labelleft=False)
for ax in axs.flat:
ax.set_xlabel('')
ax.tick_params(top=False)
max_licks = -np.inf
for ax in axs.flat:
max_licks = max(max_licks, ax.get_ylim()[1])
for ax in axs.flat:
ax.set_ylim(top=max_licks)
for ax in list(axs.flat)[1:]:
legend = ax.get_legend()
if legend is not None:
legend.set_visible(False)
for expt_grp, ax in zip(expt_grps, axs[:, -1]):
plotting.right_label(ax, expt_grp.label())
fig.suptitle(
'Number of licks near/away from reward\ngroupby = {}'.format(groupby))
return fig
def salience_responsiveness_figure_by_cell(
expt_grp, stimuli, plotby, method='responsiveness', pre_time=None,
post_time=None, channel='Ch2', label=None, roi_filter=None,
exclude_running=False, rasterized=False, save_data=False,
n_bootstraps=10000, n_processes=1):
"""Plots the stimulus responsiveness versus the 'plotby'. For example, the
response to water rewards over days of exposure.
Yields 1 figure per ROI with a grid of plots, 1 per stimulus in 'stimuli'.
Parameters
----------
expt_grp, channel, label, roi_filter
Standard analysis arguments.
stimuli : list
List of stimuli.
plotby : list
List of keys that will determine the x-axis of the plot.
See lab.plotting.plotting_helpers.prepare_dataframe
method : 'responsiveness' or 'peak'
Method to determine the response to the stimuli.
pre_time, post_time : float
Duration of baseline (pre_time) and response time (post_time).
Yields
------
mpl.pyplot.Figure
"""
# data_to_save = {}
N_COLS = 4
n_rows = int(np.ceil(len(stimuli) / float(N_COLS)))
n_extra_axs = (N_COLS * n_rows) % len(stimuli)
if exclude_running:
stimuli = [stim for stim in stimuli if 'running' not in stim]
if not len(stimuli):
warn("No stimuli to analyze, aborting.")
return
if method == 'responsiveness':
activity_label = 'Responsiveness (dF/F)'
elif method == 'peak':
activity_label = 'Peak responsiveness (dF/F)'
else:
raise ValueError("Unrecognized 'method' value")
responsiveness = {}
all_roi_tuples = set()
for stimulus in stimuli:
stimulus_dfs = []
for key, grp in expt_grp.groupby(plotby):
df = ia.response_magnitudes(
grp, stimulus, method=method, pre_time=pre_time,
post_time=post_time, data=None,
exclude='running' if exclude_running else None,
channel=channel, label=label,
roi_filter=roi_filter, return_df=True)
# Put the grouping info back in the dataframe
# For example:
# plotby = ['condition_day']
# keys will be ['A_0', 'A_1', 'B_0', etc...]
# So df['condition_day'] == 'A_0' for the first group, etc.
for key_value, grouping in zip(key, plotby):
df[grouping] = key_value
stimulus_dfs.append(df)
joined_df = pd.concat(
stimulus_dfs, ignore_index=True)
joined_df['roi_tuple'] = zip(
joined_df['mouse'].apply(lambda mouse: mouse.get('mouseID')),
joined_df['uniqueLocationKey'],
joined_df['roi_id'])
responsiveness[stimulus] = joined_df
all_roi_tuples = all_roi_tuples.union(joined_df['roi_tuple'])
for roi_tuple in sorted(all_roi_tuples):
fig, axs = plt.subplots(
n_rows, N_COLS, figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
fig.subplots_adjust(hspace=0.3)
first_col_axs = axs[:, 0]
fig.suptitle(roi_tuple)
min_response_y_lim, max_response_y_lim = np.inf, -np.inf
for ax, stimulus in it.izip(axs.flat, stimuli):
data = responsiveness[stimulus]
data = data[data['roi_tuple'].apply(lambda val: val == roi_tuple)]
plotting.plot_dataframe(
ax, [data],
activity_label=activity_label, groupby=None, plotby=plotby,
orderby=None, plot_method='line', plot_shuffle=False,
shuffle_plotby=False, pool_shuffle=False,
agg_fn=np.mean)
min_response_y_lim = np.amin([min_response_y_lim, ax.get_ylim()[0]])
max_response_y_lim = np.amax([max_response_y_lim, ax.get_ylim()[1]])
ax.set_title(stimulus)
plt.setp(ax.get_xticklabels(), rotation='40',
horizontalalignment='right')
if n_extra_axs:
for ax in np.array(axs.flat)[-n_extra_axs:]:
ax.set_visible(False)
for ax in set(axs.flat).difference(first_col_axs):
ax.set_ylabel('')
for ax in axs.flat:
ax.set_ylim(min_response_y_lim, max_response_y_lim)
ax.set_xlabel('')
legend = ax.get_legend()
if legend is not None:
legend.set_visible(False)
yield fig
def behavior_psth_figure(
expt_grps, stimulus_key, data_key, groupby, rasterized=False,
**behaviorPSTH_kwargs):
"""Returns a figure of behavior data PSTHS of experiment subgroups.
Figure will be an array of plots, n_expt_grps x n_groupby_groups.
"""
all_expts = lab.ExperimentGroup([expt for expt in it.chain(*expt_grps)])
n_groupbys = len(list(all_expts.groupby(groupby)))
fig, axs = plt.subplots(
len(expt_grps), n_groupbys, figsize=(15, 8), squeeze=False,
subplot_kw={'rasterized': rasterized})
for grp_axs, (grp_label, subgrp) in zip(axs.T, all_expts.groupby(groupby)):
for ax, expt_grp in zip(grp_axs, expt_grps):
expt_grp_subgrp = copy(expt_grp)
expt_grp_subgrp.filter(lambda expt: expt in subgrp)
if not len(expt_grp_subgrp):
ax.set_visible(False)
continue
lab.analysis.behavior_analysis.plotBehaviorPSTH(
expt_grp_subgrp, stimulus_key, data_key, ax=ax,
**behaviorPSTH_kwargs)
grp_axs[0].set_title(str(grp_label))
for ax, expt_grp in zip(axs[:, -1], expt_grps):
plotting.right_label(ax, expt_grp.label())
fig.suptitle('{} triggered {} PSTH\ngroupby={}'.format(
stimulus_key, data_key, groupby))
return fig
| mit |
trondeau/gnuradio | gnuradio-runtime/apps/evaluation_random_numbers.py | 26 | 5155 | #!/usr/bin/env python
#
# Copyright 2015 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio 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 3, or (at your option)
# any later version.
#
# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#
from gnuradio import gr
import numpy as np
from scipy.stats import norm, laplace, rayleigh
from matplotlib import pyplot as plt
# NOTE: scipy and matplotlib are optional packages and not included in the default gnuradio dependencies
#*** SETUP ***#
# Number of realisations per histogram
num_tests = 1000000
# Set number of bins in histograms
uniform_num_bins = 31
gauss_num_bins = 31
rayleigh_num_bins = 31
laplace_num_bins = 31
rndm = gr.random() # instance of gnuradio random class (gr::random)
print 'All histograms contain',num_tests,'realisations.'
#*** GENERATE DATA ***#
uniform_values = np.zeros(num_tests)
gauss_values = np.zeros(num_tests)
rayleigh_values = np.zeros(num_tests)
laplace_values = np.zeros(num_tests)
for k in range(num_tests):
uniform_values[k] = rndm.ran1()
gauss_values[k] = rndm.gasdev()
rayleigh_values[k] = rndm.rayleigh()
laplace_values[k] = rndm.laplacian()
#*** HISTOGRAM DATA AND CALCULATE EXPECTED COUNTS ***#
uniform_bins = np.linspace(0,1,uniform_num_bins)
gauss_bins = np.linspace(-8,8,gauss_num_bins)
laplace_bins = np.linspace(-8,8,laplace_num_bins)
rayleigh_bins = np.linspace(0,10,rayleigh_num_bins)
uniform_hist = np.histogram(uniform_values,uniform_bins)
gauss_hist = np.histogram(gauss_values,gauss_bins)
rayleigh_hist = np.histogram(rayleigh_values,rayleigh_bins)
laplace_hist = np.histogram(laplace_values,laplace_bins)
uniform_expected = np.zeros(uniform_num_bins-1)
gauss_expected = np.zeros(gauss_num_bins-1)
rayleigh_expected = np.zeros(rayleigh_num_bins-1)
laplace_expected = np.zeros(laplace_num_bins-1)
for k in range(len(uniform_hist[0])):
uniform_expected[k] = num_tests/float(uniform_num_bins-1)
for k in range(len(gauss_hist[0])):
gauss_expected[k] = float(norm.cdf(gauss_hist[1][k+1])-norm.cdf(gauss_hist[1][k]))*num_tests
for k in range(len(rayleigh_hist[0])):
rayleigh_expected[k] = float(rayleigh.cdf(rayleigh_hist[1][k+1])-rayleigh.cdf(rayleigh_hist[1][k]))*num_tests
for k in range(len(laplace_hist[0])):
laplace_expected[k] = float(laplace.cdf(laplace_hist[1][k+1])-laplace.cdf(laplace_hist[1][k]))*num_tests
#*** PLOT HISTOGRAMS AND EXPECTATIONS TAKEN FROM SCIPY ***#
uniform_bins_center = uniform_bins[0:-1]+(uniform_bins[1]-uniform_bins[0])/2.0
gauss_bins_center = gauss_bins[0:-1]+(gauss_bins[1]-gauss_bins[0])/2.0
rayleigh_bins_center = rayleigh_bins[0:-1]+(rayleigh_bins[1]-rayleigh_bins[0])/2.0
laplace_bins_center = laplace_bins[0:-1]+(laplace_bins[1]-laplace_bins[0])/2.0
plt.figure(1)
plt.subplot(2,1,1)
plt.plot(uniform_bins_center,uniform_hist[0],'s--',uniform_bins_center,uniform_expected,'o:')
plt.xlabel('Bins'), plt.ylabel('Count'), plt.title('Uniform: Distribution')
plt.legend(['histogram gr::random','calculation scipy'],loc=1)
plt.subplot(2,1,2)
plt.plot(uniform_bins_center,uniform_hist[0]/uniform_expected,'rs--')
plt.xlabel('Bins'), plt.ylabel('Relative deviation'), plt.title('Uniform: Relative deviation to scipy')
plt.figure(2)
plt.subplot(2,1,1)
plt.plot(gauss_bins_center,gauss_hist[0],'s--',gauss_bins_center,gauss_expected,'o:')
plt.xlabel('Bins'), plt.ylabel('Count'), plt.title('Gauss: Distribution')
plt.legend(['histogram gr::random','calculation scipy'],loc=1)
plt.subplot(2,1,2)
plt.plot(gauss_bins_center,gauss_hist[0]/gauss_expected,'rs--')
plt.xlabel('Bins'), plt.ylabel('Relative deviation'), plt.title('Gauss: Relative deviation to scipy')
plt.figure(3)
plt.subplot(2,1,1)
plt.plot(rayleigh_bins_center,rayleigh_hist[0],'s--',rayleigh_bins_center,rayleigh_expected,'o:')
plt.xlabel('Bins'), plt.ylabel('Count'), plt.title('Rayleigh: Distribution')
plt.legend(['histogram gr::random','calculation scipy'],loc=1)
plt.subplot(2,1,2)
plt.plot(rayleigh_bins_center,rayleigh_hist[0]/rayleigh_expected,'rs--')
plt.xlabel('Bins'), plt.ylabel('Relative deviation'), plt.title('Rayleigh: Relative deviation to scipy')
plt.figure(4)
plt.subplot(2,1,1)
plt.plot(laplace_bins_center,laplace_hist[0],'s--',laplace_bins_center,laplace_expected,'o:')
plt.xlabel('Bins'), plt.ylabel('Count'), plt.title('Laplace: Distribution')
plt.legend(['histogram gr::random','calculation scipy'],loc=1)
plt.subplot(2,1,2)
plt.plot(laplace_bins_center,laplace_hist[0]/laplace_expected,'rs--')
plt.xlabel('Bins'), plt.ylabel('Relative deviation'), plt.title('Laplace: Relative deviation to scipy')
plt.show()
| gpl-3.0 |
jungla/ICOM-fluidity-toolbox | Detectors/plot_traj_v.py | 1 | 2677 | #!~/python
import fluidity_tools
import matplotlib as mpl
mpl.use('ps')
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import myfun
import numpy as np
import pyvtk
import vtktools
import copy
import os
exp = 'm_250_8c_str'
filename = '/nethome/jmensa/fluidity-exp/'+exp+'/mli_checkpoint.detectors'
day = '400'
try: os.stat('./plot/'+exp)
except OSError: os.mkdir('./plot/'+exp)
print 'reading detectors'
det = fluidity_tools.stat_parser(filename)
keys = det.keys() # particles
print 'done.'
tt = 80
pt = 450000
step = 1
# dimensions particles
lat = 15000
lon = 7500
depth = -50
nlat = 100
nlon = 100
ndepth = 5
depth_ml = -30
y = range(100, lat+100, nlat)
x = range(100, lon+100, nlon)
z = np.linspace(0, depth, ndepth)
[Xf,Yf,Zf] = myfun.meshgrid2(x,y,z)
Yf = np.reshape(Yf,np.size(Yf,))
Xf = np.reshape(Xf,np.size(Xf,))
Zf = np.reshape(Zf,np.size(Zf,))
# dimensions archives
xstep = 150
ystep = 150
zstep = -1
Xlist = np.arange(0.0,lon+xstep,xstep)# x co-ordinates of the desired array shape
Ylist = np.arange(0.0,lat+ystep,ystep)# y co-ordinates of the desired array shape
Zlist = np.arange(0.0,depth_ml+zstep,zstep)# y co-ordinates of the desired array shape
[X,Y,Z] = myfun.meshgrid2(Xlist,Ylist,Zlist)
Y = np.reshape(Y,(np.size(Y),))
X = np.reshape(X,(np.size(X),))
Z = np.reshape(Z,(np.size(Z),))
par = np.zeros((pt,3,tt))
time = det['ElapsedTime']['value']
# read particles
for d in range(pt):
temp = det['Particles_'+myfun.digit(d+1,6)]['position']
par[d,:,:] = temp[:,0:tt]
# read ML depth from file
Tref = [0.2,0.3]
mld = []
for i in range(len(Tref)):
Data = pyvtk.VtkData('/nethome/jmensa/scripts_fluidity/2D/ML/output/'+exp+'/ML_'+myfun.digit(Tref[i],3)+'_'+exp+'_'+day+'.vtk')
mld.append(np.reshape(Data.point_data.data[0].scalars,[len(Ylist),len(Xlist)]))
# read T from archive
data = vtktools.vtu('/tamay/mensa/fluidity/'+exp+'/mli_'+day+'.pvtu')
Ts = np.reshape(data.ProbeData(vtktools.arr(zip(X,Y,Z)), 'Temperature'),[len(Zlist),len(Ylist),len(Xlist)])
# for future plotting
Yf, Zf = np.meshgrid(Ylist,Zlist)
Y, Z = np.meshgrid(y,z)
plt.figure()
# plt.gca().set_aspect('equal')
plt.contourf(Y,Z,np.flipud(np.rot90(np.mean(fsler,axis=1))),10,cmap='jet')
plt.colorbar()
plt.contour(Yf,Zf,np.mean(Ts,axis=2),20,colors='White',linewidth=4.0)
# plt.contourf(np.rot90(fsler[:,nlon/2,:]))
for i in range(len(Tref)):
mmld = np.mean(mld[i],axis=1)
plt.plot(Ylist,mmld,color='k',linewidth=4.0)
# plt.text(1000*(i+1),mmld[1]+1,myfun.digit(Tref[i],3))
for d in range(pt):
plt.plot(Ylist,Zlist,par[d,1:2,:])
plt.savefig('./plot/'+exp+'/traj_'+exp+'_'+day+'.eps',bbox_inches='tight')
plt.close()
| gpl-2.0 |
Odingod/mne-python | mne/tests/test_source_estimate.py | 12 | 28321 | from __future__ import print_function
import os.path as op
from nose.tools import assert_true, assert_raises
import warnings
from copy import deepcopy
import numpy as np
from numpy.testing import (assert_array_almost_equal, assert_array_equal,
assert_allclose, assert_equal)
from scipy.fftpack import fft
from mne.datasets import testing
from mne import (stats, SourceEstimate, VolSourceEstimate, Label,
read_source_spaces, MixedSourceEstimate)
from mne import read_source_estimate, morph_data, extract_label_time_course
from mne.source_estimate import (spatio_temporal_tris_connectivity,
spatio_temporal_src_connectivity,
compute_morph_matrix, grade_to_vertices,
grade_to_tris)
from mne.minimum_norm import read_inverse_operator
from mne.label import read_labels_from_annot, label_sign_flip
from mne.utils import (_TempDir, requires_pandas, requires_sklearn,
requires_h5py, run_tests_if_main, slow_test)
warnings.simplefilter('always') # enable b/c these tests throw warnings
data_path = testing.data_path(download=False)
subjects_dir = op.join(data_path, 'subjects')
fname_inv = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc-meg-eeg-oct-6-meg-inv.fif')
fname_t1 = op.join(data_path, 'subjects', 'sample', 'mri', 'T1.mgz')
fname_src = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc-meg-eeg-oct-6-fwd.fif')
fname_stc = op.join(data_path, 'MEG', 'sample', 'sample_audvis_trunc-meg')
fname_smorph = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc-meg')
fname_fmorph = op.join(data_path, 'MEG', 'sample',
'fsaverage_audvis_trunc-meg')
fname_vol = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc-grad-vol-7-fwd-sensmap-vol.w')
fname_vsrc = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc-meg-vol-7-fwd.fif')
@slow_test
@testing.requires_testing_data
def test_volume_stc():
"""Test volume STCs
"""
tempdir = _TempDir()
N = 100
data = np.arange(N)[:, np.newaxis]
datas = [data, data, np.arange(2)[:, np.newaxis]]
vertno = np.arange(N)
vertnos = [vertno, vertno[:, np.newaxis], np.arange(2)[:, np.newaxis]]
vertno_reads = [vertno, vertno, np.arange(2)]
for data, vertno, vertno_read in zip(datas, vertnos, vertno_reads):
stc = VolSourceEstimate(data, vertno, 0, 1)
fname_temp = op.join(tempdir, 'temp-vl.stc')
stc_new = stc
for _ in range(2):
stc_new.save(fname_temp)
stc_new = read_source_estimate(fname_temp)
assert_true(isinstance(stc_new, VolSourceEstimate))
assert_array_equal(vertno_read, stc_new.vertices)
assert_array_almost_equal(stc.data, stc_new.data)
# now let's actually read a MNE-C processed file
stc = read_source_estimate(fname_vol, 'sample')
assert_true(isinstance(stc, VolSourceEstimate))
assert_true('sample' in repr(stc))
stc_new = stc
assert_raises(ValueError, stc.save, fname_vol, ftype='whatever')
for _ in range(2):
fname_temp = op.join(tempdir, 'temp-vol.w')
stc_new.save(fname_temp, ftype='w')
stc_new = read_source_estimate(fname_temp)
assert_true(isinstance(stc_new, VolSourceEstimate))
assert_array_equal(stc.vertices, stc_new.vertices)
assert_array_almost_equal(stc.data, stc_new.data)
# save the stc as a nifti file and export
try:
import nibabel as nib
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
src = read_source_spaces(fname_vsrc)
vol_fname = op.join(tempdir, 'stc.nii.gz')
stc.save_as_volume(vol_fname, src,
dest='surf', mri_resolution=False)
with warnings.catch_warnings(record=True): # nib<->numpy
img = nib.load(vol_fname)
assert_true(img.shape == src[0]['shape'] + (len(stc.times),))
with warnings.catch_warnings(record=True): # nib<->numpy
t1_img = nib.load(fname_t1)
stc.save_as_volume(op.join(tempdir, 'stc.nii.gz'), src,
dest='mri', mri_resolution=True)
with warnings.catch_warnings(record=True): # nib<->numpy
img = nib.load(vol_fname)
assert_true(img.shape == t1_img.shape + (len(stc.times),))
assert_array_almost_equal(img.get_affine(), t1_img.get_affine(),
decimal=5)
# export without saving
img = stc.as_volume(src, dest='mri', mri_resolution=True)
assert_true(img.shape == t1_img.shape + (len(stc.times),))
assert_array_almost_equal(img.get_affine(), t1_img.get_affine(),
decimal=5)
except ImportError:
print('Save as nifti test skipped, needs NiBabel')
@testing.requires_testing_data
def test_expand():
"""Test stc expansion
"""
stc = read_source_estimate(fname_stc, 'sample')
assert_true('sample' in repr(stc))
labels_lh = read_labels_from_annot('sample', 'aparc', 'lh',
subjects_dir=subjects_dir)
new_label = labels_lh[0] + labels_lh[1]
stc_limited = stc.in_label(new_label)
stc_new = stc_limited.copy()
stc_new.data.fill(0)
for label in labels_lh[:2]:
stc_new += stc.in_label(label).expand(stc_limited.vertices)
assert_raises(TypeError, stc_new.expand, stc_limited.vertices[0])
assert_raises(ValueError, stc_new.expand, [stc_limited.vertices[0]])
# make sure we can't add unless vertno agree
assert_raises(ValueError, stc.__add__, stc.in_label(labels_lh[0]))
def _fake_stc(n_time=10):
verts = [np.arange(10), np.arange(90)]
return SourceEstimate(np.random.rand(100, n_time), verts, 0, 1e-1, 'foo')
def test_io_stc():
"""Test IO for STC files
"""
tempdir = _TempDir()
stc = _fake_stc()
stc.save(op.join(tempdir, "tmp.stc"))
stc2 = read_source_estimate(op.join(tempdir, "tmp.stc"))
assert_array_almost_equal(stc.data, stc2.data)
assert_array_almost_equal(stc.tmin, stc2.tmin)
assert_equal(len(stc.vertices), len(stc2.vertices))
for v1, v2 in zip(stc.vertices, stc2.vertices):
assert_array_almost_equal(v1, v2)
assert_array_almost_equal(stc.tstep, stc2.tstep)
@requires_h5py
def test_io_stc_h5():
"""Test IO for STC files using HDF5
"""
tempdir = _TempDir()
stc = _fake_stc()
assert_raises(ValueError, stc.save, op.join(tempdir, 'tmp'), ftype='foo')
out_name = op.join(tempdir, 'tmp')
stc.save(out_name, ftype='h5')
stc3 = read_source_estimate(out_name)
stc4 = read_source_estimate(out_name + '-stc.h5')
assert_raises(RuntimeError, read_source_estimate, out_name, subject='bar')
for stc_new in stc3, stc4:
assert_equal(stc_new.subject, stc.subject)
assert_array_equal(stc_new.data, stc.data)
assert_array_equal(stc_new.tmin, stc.tmin)
assert_array_equal(stc_new.tstep, stc.tstep)
assert_equal(len(stc_new.vertices), len(stc.vertices))
for v1, v2 in zip(stc_new.vertices, stc.vertices):
assert_array_equal(v1, v2)
def test_io_w():
"""Test IO for w files
"""
tempdir = _TempDir()
stc = _fake_stc(n_time=1)
w_fname = op.join(tempdir, 'fake')
stc.save(w_fname, ftype='w')
src = read_source_estimate(w_fname)
src.save(op.join(tempdir, 'tmp'), ftype='w')
src2 = read_source_estimate(op.join(tempdir, 'tmp-lh.w'))
assert_array_almost_equal(src.data, src2.data)
assert_array_almost_equal(src.lh_vertno, src2.lh_vertno)
assert_array_almost_equal(src.rh_vertno, src2.rh_vertno)
def test_stc_arithmetic():
"""Test arithmetic for STC files
"""
stc = _fake_stc()
data = stc.data.copy()
out = list()
for a in [data, stc]:
a = a + a * 3 + 3 * a - a ** 2 / 2
a += a
a -= a
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
a /= 2 * a
a *= -a
a += 2
a -= 1
a *= -1
a /= 2
b = 2 + a
b = 2 - a
b = +a
assert_array_equal(b.data, a.data)
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
a **= 3
out.append(a)
assert_array_equal(out[0], out[1].data)
assert_array_equal(stc.sqrt().data, np.sqrt(stc.data))
stc_mean = stc.mean()
assert_array_equal(stc_mean.data, np.mean(stc.data, 1)[:, None])
@slow_test
@testing.requires_testing_data
def test_stc_methods():
"""Test stc methods lh_data, rh_data, bin(), center_of_mass(), resample()
"""
stc = read_source_estimate(fname_stc)
# lh_data / rh_data
assert_array_equal(stc.lh_data, stc.data[:len(stc.lh_vertno)])
assert_array_equal(stc.rh_data, stc.data[len(stc.lh_vertno):])
# bin
bin = stc.bin(.12)
a = np.array((1,), dtype=stc.data.dtype)
a[0] = np.mean(stc.data[0, stc.times < .12])
assert a[0] == bin.data[0, 0]
assert_raises(ValueError, stc.center_of_mass, 'sample')
stc.lh_data[:] = 0
vertex, hemi, t = stc.center_of_mass('sample', subjects_dir=subjects_dir)
assert_true(hemi == 1)
# XXX Should design a fool-proof test case, but here were the results:
assert_equal(vertex, 124791)
assert_equal(np.round(t, 2), 0.12)
stc = read_source_estimate(fname_stc)
stc.subject = 'sample'
label_lh = read_labels_from_annot('sample', 'aparc', 'lh',
subjects_dir=subjects_dir)[0]
label_rh = read_labels_from_annot('sample', 'aparc', 'rh',
subjects_dir=subjects_dir)[0]
label_both = label_lh + label_rh
for label in (label_lh, label_rh, label_both):
assert_true(isinstance(stc.shape, tuple) and len(stc.shape) == 2)
stc_label = stc.in_label(label)
if label.hemi != 'both':
if label.hemi == 'lh':
verts = stc_label.vertices[0]
else: # label.hemi == 'rh':
verts = stc_label.vertices[1]
n_vertices_used = len(label.get_vertices_used(verts))
assert_equal(len(stc_label.data), n_vertices_used)
stc_lh = stc.in_label(label_lh)
assert_raises(ValueError, stc_lh.in_label, label_rh)
label_lh.subject = 'foo'
assert_raises(RuntimeError, stc.in_label, label_lh)
stc_new = deepcopy(stc)
o_sfreq = 1.0 / stc.tstep
# note that using no padding for this STC reduces edge ringing...
stc_new.resample(2 * o_sfreq, npad=0, n_jobs=2)
assert_true(stc_new.data.shape[1] == 2 * stc.data.shape[1])
assert_true(stc_new.tstep == stc.tstep / 2)
stc_new.resample(o_sfreq, npad=0)
assert_true(stc_new.data.shape[1] == stc.data.shape[1])
assert_true(stc_new.tstep == stc.tstep)
assert_array_almost_equal(stc_new.data, stc.data, 5)
@testing.requires_testing_data
def test_extract_label_time_course():
"""Test extraction of label time courses from stc
"""
n_stcs = 3
n_times = 50
src = read_inverse_operator(fname_inv)['src']
vertices = [src[0]['vertno'], src[1]['vertno']]
n_verts = len(vertices[0]) + len(vertices[1])
# get some labels
labels_lh = read_labels_from_annot('sample', hemi='lh',
subjects_dir=subjects_dir)
labels_rh = read_labels_from_annot('sample', hemi='rh',
subjects_dir=subjects_dir)
labels = list()
labels.extend(labels_lh[:5])
labels.extend(labels_rh[:4])
n_labels = len(labels)
label_means = np.arange(n_labels)[:, None] * np.ones((n_labels, n_times))
label_maxs = np.arange(n_labels)[:, None] * np.ones((n_labels, n_times))
# compute the mean with sign flip
label_means_flipped = np.zeros_like(label_means)
for i, label in enumerate(labels):
label_means_flipped[i] = i * np.mean(label_sign_flip(label, src))
# generate some stc's with known data
stcs = list()
for i in range(n_stcs):
data = np.zeros((n_verts, n_times))
# set the value of the stc within each label
for j, label in enumerate(labels):
if label.hemi == 'lh':
idx = np.intersect1d(vertices[0], label.vertices)
idx = np.searchsorted(vertices[0], idx)
elif label.hemi == 'rh':
idx = np.intersect1d(vertices[1], label.vertices)
idx = len(vertices[0]) + np.searchsorted(vertices[1], idx)
data[idx] = label_means[j]
this_stc = SourceEstimate(data, vertices, 0, 1)
stcs.append(this_stc)
# test some invalid inputs
assert_raises(ValueError, extract_label_time_course, stcs, labels,
src, mode='notamode')
# have an empty label
empty_label = labels[0].copy()
empty_label.vertices += 1000000
assert_raises(ValueError, extract_label_time_course, stcs, empty_label,
src, mode='mean')
# but this works:
tc = extract_label_time_course(stcs, empty_label, src, mode='mean',
allow_empty=True)
for arr in tc:
assert_true(arr.shape == (1, n_times))
assert_array_equal(arr, np.zeros((1, n_times)))
# test the different modes
modes = ['mean', 'mean_flip', 'pca_flip', 'max']
for mode in modes:
label_tc = extract_label_time_course(stcs, labels, src, mode=mode)
label_tc_method = [stc.extract_label_time_course(labels, src,
mode=mode) for stc in stcs]
assert_true(len(label_tc) == n_stcs)
assert_true(len(label_tc_method) == n_stcs)
for tc1, tc2 in zip(label_tc, label_tc_method):
assert_true(tc1.shape == (n_labels, n_times))
assert_true(tc2.shape == (n_labels, n_times))
assert_true(np.allclose(tc1, tc2, rtol=1e-8, atol=1e-16))
if mode == 'mean':
assert_array_almost_equal(tc1, label_means)
if mode == 'mean_flip':
assert_array_almost_equal(tc1, label_means_flipped)
if mode == 'max':
assert_array_almost_equal(tc1, label_maxs)
# test label with very few vertices (check SVD conditionals)
label = Label(vertices=src[0]['vertno'][:2], hemi='lh')
x = label_sign_flip(label, src)
assert_true(len(x) == 2)
label = Label(vertices=[], hemi='lh')
x = label_sign_flip(label, src)
assert_true(x.size == 0)
@slow_test
@testing.requires_testing_data
def test_morph_data():
"""Test morphing of data
"""
tempdir = _TempDir()
subject_from = 'sample'
subject_to = 'fsaverage'
stc_from = read_source_estimate(fname_smorph, subject='sample')
stc_to = read_source_estimate(fname_fmorph)
# make sure we can specify grade
stc_from.crop(0.09, 0.1) # for faster computation
stc_to.crop(0.09, 0.1) # for faster computation
assert_raises(ValueError, stc_from.morph, subject_to, grade=3, smooth=-1,
subjects_dir=subjects_dir)
stc_to1 = stc_from.morph(subject_to, grade=3, smooth=12, buffer_size=1000,
subjects_dir=subjects_dir)
stc_to1.save(op.join(tempdir, '%s_audvis-meg' % subject_to))
# make sure we can specify vertices
vertices_to = grade_to_vertices(subject_to, grade=3,
subjects_dir=subjects_dir)
stc_to2 = morph_data(subject_from, subject_to, stc_from,
grade=vertices_to, smooth=12, buffer_size=1000,
subjects_dir=subjects_dir)
# make sure we can use different buffer_size
stc_to3 = morph_data(subject_from, subject_to, stc_from,
grade=vertices_to, smooth=12, buffer_size=3,
subjects_dir=subjects_dir)
# make sure we get a warning about # of steps
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
morph_data(subject_from, subject_to, stc_from,
grade=vertices_to, smooth=1, buffer_size=3,
subjects_dir=subjects_dir)
assert_equal(len(w), 2)
assert_array_almost_equal(stc_to.data, stc_to1.data, 5)
assert_array_almost_equal(stc_to1.data, stc_to2.data)
assert_array_almost_equal(stc_to1.data, stc_to3.data)
# make sure precomputed morph matrices work
morph_mat = compute_morph_matrix(subject_from, subject_to,
stc_from.vertices, vertices_to,
smooth=12, subjects_dir=subjects_dir)
stc_to3 = stc_from.morph_precomputed(subject_to, vertices_to, morph_mat)
assert_array_almost_equal(stc_to1.data, stc_to3.data)
assert_raises(ValueError, stc_from.morph_precomputed,
subject_to, vertices_to, 'foo')
assert_raises(ValueError, stc_from.morph_precomputed,
subject_to, [vertices_to[0]], morph_mat)
assert_raises(ValueError, stc_from.morph_precomputed,
subject_to, [vertices_to[0][:-1], vertices_to[1]], morph_mat)
assert_raises(ValueError, stc_from.morph_precomputed, subject_to,
vertices_to, morph_mat, subject_from='foo')
# steps warning
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
compute_morph_matrix(subject_from, subject_to,
stc_from.vertices, vertices_to,
smooth=1, subjects_dir=subjects_dir)
assert_equal(len(w), 2)
mean_from = stc_from.data.mean(axis=0)
mean_to = stc_to1.data.mean(axis=0)
assert_true(np.corrcoef(mean_to, mean_from).min() > 0.999)
# make sure we can fill by morphing
stc_to5 = morph_data(subject_from, subject_to, stc_from, grade=None,
smooth=12, buffer_size=3, subjects_dir=subjects_dir)
assert_true(stc_to5.data.shape[0] == 163842 + 163842)
# Morph sparse data
# Make a sparse stc
stc_from.vertices[0] = stc_from.vertices[0][[100, 500]]
stc_from.vertices[1] = stc_from.vertices[1][[200]]
stc_from._data = stc_from._data[:3]
assert_raises(RuntimeError, stc_from.morph, subject_to, sparse=True,
grade=5, subjects_dir=subjects_dir)
stc_to_sparse = stc_from.morph(subject_to, grade=None, sparse=True,
subjects_dir=subjects_dir)
assert_array_almost_equal(np.sort(stc_from.data.sum(axis=1)),
np.sort(stc_to_sparse.data.sum(axis=1)))
assert_equal(len(stc_from.rh_vertno), len(stc_to_sparse.rh_vertno))
assert_equal(len(stc_from.lh_vertno), len(stc_to_sparse.lh_vertno))
assert_equal(stc_to_sparse.subject, subject_to)
assert_equal(stc_from.tmin, stc_from.tmin)
assert_equal(stc_from.tstep, stc_from.tstep)
stc_from.vertices[0] = np.array([], dtype=np.int64)
stc_from._data = stc_from._data[:1]
stc_to_sparse = stc_from.morph(subject_to, grade=None, sparse=True,
subjects_dir=subjects_dir)
assert_array_almost_equal(np.sort(stc_from.data.sum(axis=1)),
np.sort(stc_to_sparse.data.sum(axis=1)))
assert_equal(len(stc_from.rh_vertno), len(stc_to_sparse.rh_vertno))
assert_equal(len(stc_from.lh_vertno), len(stc_to_sparse.lh_vertno))
assert_equal(stc_to_sparse.subject, subject_to)
assert_equal(stc_from.tmin, stc_from.tmin)
assert_equal(stc_from.tstep, stc_from.tstep)
def _my_trans(data):
"""FFT that adds an additional dimension by repeating result"""
data_t = fft(data)
data_t = np.concatenate([data_t[:, :, None], data_t[:, :, None]], axis=2)
return data_t, None
def test_transform_data():
"""Test applying linear (time) transform to data"""
# make up some data
n_sensors, n_vertices, n_times = 10, 20, 4
kernel = np.random.randn(n_vertices, n_sensors)
sens_data = np.random.randn(n_sensors, n_times)
vertices = np.arange(n_vertices)
data = np.dot(kernel, sens_data)
for idx, tmin_idx, tmax_idx in\
zip([None, np.arange(n_vertices // 2, n_vertices)],
[None, 1], [None, 3]):
if idx is None:
idx_use = slice(None, None)
else:
idx_use = idx
data_f, _ = _my_trans(data[idx_use, tmin_idx:tmax_idx])
for stc_data in (data, (kernel, sens_data)):
stc = VolSourceEstimate(stc_data, vertices=vertices,
tmin=0., tstep=1.)
stc_data_t = stc.transform_data(_my_trans, idx=idx,
tmin_idx=tmin_idx,
tmax_idx=tmax_idx)
assert_allclose(data_f, stc_data_t)
def test_transform():
"""Test applying linear (time) transform to data"""
# make up some data
n_verts_lh, n_verts_rh, n_times = 10, 10, 10
vertices = [np.arange(n_verts_lh), n_verts_lh + np.arange(n_verts_rh)]
data = np.random.randn(n_verts_lh + n_verts_rh, n_times)
stc = SourceEstimate(data, vertices=vertices, tmin=-0.1, tstep=0.1)
# data_t.ndim > 2 & copy is True
stcs_t = stc.transform(_my_trans, copy=True)
assert_true(isinstance(stcs_t, list))
assert_array_equal(stc.times, stcs_t[0].times)
assert_equal(stc.vertices, stcs_t[0].vertices)
data = np.concatenate((stcs_t[0].data[:, :, None],
stcs_t[1].data[:, :, None]), axis=2)
data_t = stc.transform_data(_my_trans)
assert_array_equal(data, data_t) # check against stc.transform_data()
# data_t.ndim > 2 & copy is False
assert_raises(ValueError, stc.transform, _my_trans, copy=False)
# data_t.ndim = 2 & copy is True
tmp = deepcopy(stc)
stc_t = stc.transform(np.abs, copy=True)
assert_true(isinstance(stc_t, SourceEstimate))
assert_array_equal(stc.data, tmp.data) # xfrm doesn't modify original?
# data_t.ndim = 2 & copy is False
times = np.round(1000 * stc.times)
verts = np.arange(len(stc.lh_vertno),
len(stc.lh_vertno) + len(stc.rh_vertno), 1)
verts_rh = stc.rh_vertno
t_idx = [np.where(times >= -50)[0][0], np.where(times <= 500)[0][-1]]
data_t = stc.transform_data(np.abs, idx=verts, tmin_idx=t_idx[0],
tmax_idx=t_idx[-1])
stc.transform(np.abs, idx=verts, tmin=-50, tmax=500, copy=False)
assert_true(isinstance(stc, SourceEstimate))
assert_true((stc.tmin == 0.) & (stc.times[-1] == 0.5))
assert_true(len(stc.vertices[0]) == 0)
assert_equal(stc.vertices[1], verts_rh)
assert_array_equal(stc.data, data_t)
times = np.round(1000 * stc.times)
t_idx = [np.where(times >= 0)[0][0], np.where(times <= 250)[0][-1]]
data_t = stc.transform_data(np.abs, tmin_idx=t_idx[0], tmax_idx=t_idx[-1])
stc.transform(np.abs, tmin=0, tmax=250, copy=False)
assert_true((stc.tmin == 0.) & (stc.times[-1] == 0.2))
assert_array_equal(stc.data, data_t)
@requires_sklearn
def test_spatio_temporal_tris_connectivity():
"""Test spatio-temporal connectivity from triangles"""
tris = np.array([[0, 1, 2], [3, 4, 5]])
connectivity = spatio_temporal_tris_connectivity(tris, 2)
x = [1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
components = stats.cluster_level._get_components(np.array(x), connectivity)
# _get_components works differently now...
old_fmt = [0, 0, -2, -2, -2, -2, 0, -2, -2, -2, -2, 1]
new_fmt = np.array(old_fmt)
new_fmt = [np.nonzero(new_fmt == v)[0]
for v in np.unique(new_fmt[new_fmt >= 0])]
assert_true(len(new_fmt), len(components))
for c, n in zip(components, new_fmt):
assert_array_equal(c, n)
@testing.requires_testing_data
def test_spatio_temporal_src_connectivity():
"""Test spatio-temporal connectivity from source spaces"""
tris = np.array([[0, 1, 2], [3, 4, 5]])
src = [dict(), dict()]
connectivity = spatio_temporal_tris_connectivity(tris, 2)
src[0]['use_tris'] = np.array([[0, 1, 2]])
src[1]['use_tris'] = np.array([[0, 1, 2]])
src[0]['vertno'] = np.array([0, 1, 2])
src[1]['vertno'] = np.array([0, 1, 2])
connectivity2 = spatio_temporal_src_connectivity(src, 2)
assert_array_equal(connectivity.todense(), connectivity2.todense())
# add test for dist connectivity
src[0]['dist'] = np.ones((3, 3)) - np.eye(3)
src[1]['dist'] = np.ones((3, 3)) - np.eye(3)
src[0]['vertno'] = [0, 1, 2]
src[1]['vertno'] = [0, 1, 2]
connectivity3 = spatio_temporal_src_connectivity(src, 2, dist=2)
assert_array_equal(connectivity.todense(), connectivity3.todense())
# add test for source space connectivity with omitted vertices
inverse_operator = read_inverse_operator(fname_inv)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
src_ = inverse_operator['src']
connectivity = spatio_temporal_src_connectivity(src_, n_times=2)
assert len(w) == 1
a = connectivity.shape[0] / 2
b = sum([s['nuse'] for s in inverse_operator['src']])
assert_true(a == b)
assert_equal(grade_to_tris(5).shape, [40960, 3])
@requires_pandas
def test_to_data_frame():
"""Test stc Pandas exporter"""
n_vert, n_times = 10, 5
vertices = [np.arange(n_vert, dtype=np.int), np.empty(0, dtype=np.int)]
data = np.random.randn(n_vert, n_times)
stc_surf = SourceEstimate(data, vertices=vertices, tmin=0, tstep=1,
subject='sample')
stc_vol = VolSourceEstimate(data, vertices=vertices[0], tmin=0, tstep=1,
subject='sample')
for stc in [stc_surf, stc_vol]:
assert_raises(ValueError, stc.to_data_frame, index=['foo', 'bar'])
for ncat, ind in zip([1, 0], ['time', ['subject', 'time']]):
df = stc.to_data_frame(index=ind)
assert_true(df.index.names == ind
if isinstance(ind, list) else [ind])
assert_array_equal(df.values.T[ncat:], stc.data)
# test that non-indexed data were present as categorial variables
assert_true(all([c in ['time', 'subject'] for c in
df.reset_index().columns][:2]))
def test_get_peak():
"""Test peak getter
"""
n_vert, n_times = 10, 5
vertices = [np.arange(n_vert, dtype=np.int), np.empty(0, dtype=np.int)]
data = np.random.randn(n_vert, n_times)
stc_surf = SourceEstimate(data, vertices=vertices, tmin=0, tstep=1,
subject='sample')
stc_vol = VolSourceEstimate(data, vertices=vertices[0], tmin=0, tstep=1,
subject='sample')
for ii, stc in enumerate([stc_surf, stc_vol]):
assert_raises(ValueError, stc.get_peak, tmin=-100)
assert_raises(ValueError, stc.get_peak, tmax=90)
assert_raises(ValueError, stc.get_peak, tmin=0.002, tmax=0.001)
vert_idx, time_idx = stc.get_peak()
vertno = np.concatenate(stc.vertices) if ii == 0 else stc.vertices
assert_true(vert_idx in vertno)
assert_true(time_idx in stc.times)
ch_idx, time_idx = stc.get_peak(vert_as_index=True,
time_as_index=True)
assert_true(vert_idx < stc.data.shape[0])
assert_true(time_idx < len(stc.times))
@testing.requires_testing_data
def test_mixed_stc():
"""Test source estimate from mixed source space
"""
N = 90 # number of sources
T = 2 # number of time points
S = 3 # number of source spaces
data = np.random.randn(N, T)
vertno = S * [np.arange(N // S)]
# make sure error is raised if vertices are not a list of length >= 2
assert_raises(ValueError, MixedSourceEstimate, data=data,
vertices=[np.arange(N)])
stc = MixedSourceEstimate(data, vertno, 0, 1)
vol = read_source_spaces(fname_vsrc)
# make sure error is raised for plotting surface with volume source
assert_raises(ValueError, stc.plot_surface, src=vol)
run_tests_if_main()
| bsd-3-clause |
fabianp/scikit-learn | sklearn/utils/validation.py | 66 | 23629 | """Utilities for input validation"""
# Authors: Olivier Grisel
# Gael Varoquaux
# Andreas Mueller
# Lars Buitinck
# Alexandre Gramfort
# Nicolas Tresegnie
# License: BSD 3 clause
import warnings
import numbers
import numpy as np
import scipy.sparse as sp
from ..externals import six
from inspect import getargspec
FLOAT_DTYPES = (np.float64, np.float32, np.float16)
class DataConversionWarning(UserWarning):
"""A warning on implicit data conversions happening in the code"""
pass
warnings.simplefilter("always", DataConversionWarning)
class NonBLASDotWarning(UserWarning):
"""A warning on implicit dispatch to numpy.dot"""
class NotFittedError(ValueError, AttributeError):
"""Exception class to raise if estimator is used before fitting
This class inherits from both ValueError and AttributeError to help with
exception handling and backward compatibility.
"""
# Silenced by default to reduce verbosity. Turn on at runtime for
# performance profiling.
warnings.simplefilter('ignore', NonBLASDotWarning)
def _assert_all_finite(X):
"""Like assert_all_finite, but only for ndarray."""
X = np.asanyarray(X)
# First try an O(n) time, O(1) space solution for the common case that
# everything is finite; fall back to O(n) space np.isfinite to prevent
# false positives from overflow in sum method.
if (X.dtype.char in np.typecodes['AllFloat'] and not np.isfinite(X.sum())
and not np.isfinite(X).all()):
raise ValueError("Input contains NaN, infinity"
" or a value too large for %r." % X.dtype)
def assert_all_finite(X):
"""Throw a ValueError if X contains NaN or infinity.
Input MUST be an np.ndarray instance or a scipy.sparse matrix."""
_assert_all_finite(X.data if sp.issparse(X) else X)
def as_float_array(X, copy=True, force_all_finite=True):
"""Converts an array-like to an array of floats
The new dtype will be np.float32 or np.float64, depending on the original
type. The function can create a copy or modify the argument depending
on the argument copy.
Parameters
----------
X : {array-like, sparse matrix}
copy : bool, optional
If True, a copy of X will be created. If False, a copy may still be
returned if X's dtype is not a floating point type.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
Returns
-------
XT : {array, sparse matrix}
An array of type np.float
"""
if isinstance(X, np.matrix) or (not isinstance(X, np.ndarray)
and not sp.issparse(X)):
return check_array(X, ['csr', 'csc', 'coo'], dtype=np.float64,
copy=copy, force_all_finite=force_all_finite,
ensure_2d=False)
elif sp.issparse(X) and X.dtype in [np.float32, np.float64]:
return X.copy() if copy else X
elif X.dtype in [np.float32, np.float64]: # is numpy array
return X.copy('F' if X.flags['F_CONTIGUOUS'] else 'C') if copy else X
else:
return X.astype(np.float32 if X.dtype == np.int32 else np.float64)
def _is_arraylike(x):
"""Returns whether the input is array-like"""
return (hasattr(x, '__len__') or
hasattr(x, 'shape') or
hasattr(x, '__array__'))
def _num_samples(x):
"""Return number of samples in array-like x."""
if hasattr(x, 'fit'):
# Don't get num_samples from an ensembles length!
raise TypeError('Expected sequence or array-like, got '
'estimator %s' % x)
if not hasattr(x, '__len__') and not hasattr(x, 'shape'):
if hasattr(x, '__array__'):
x = np.asarray(x)
else:
raise TypeError("Expected sequence or array-like, got %s" %
type(x))
if hasattr(x, 'shape'):
if len(x.shape) == 0:
raise TypeError("Singleton array %r cannot be considered"
" a valid collection." % x)
return x.shape[0]
else:
return len(x)
def _shape_repr(shape):
"""Return a platform independent reprensentation of an array shape
Under Python 2, the `long` type introduces an 'L' suffix when using the
default %r format for tuples of integers (typically used to store the shape
of an array).
Under Windows 64 bit (and Python 2), the `long` type is used by default
in numpy shapes even when the integer dimensions are well below 32 bit.
The platform specific type causes string messages or doctests to change
from one platform to another which is not desirable.
Under Python 3, there is no more `long` type so the `L` suffix is never
introduced in string representation.
>>> _shape_repr((1, 2))
'(1, 2)'
>>> one = 2 ** 64 / 2 ** 64 # force an upcast to `long` under Python 2
>>> _shape_repr((one, 2 * one))
'(1, 2)'
>>> _shape_repr((1,))
'(1,)'
>>> _shape_repr(())
'()'
"""
if len(shape) == 0:
return "()"
joined = ", ".join("%d" % e for e in shape)
if len(shape) == 1:
# special notation for singleton tuples
joined += ','
return "(%s)" % joined
def check_consistent_length(*arrays):
"""Check that all arrays have consistent first dimensions.
Checks whether all objects in arrays have the same shape or length.
Parameters
----------
*arrays : list or tuple of input objects.
Objects that will be checked for consistent length.
"""
uniques = np.unique([_num_samples(X) for X in arrays if X is not None])
if len(uniques) > 1:
raise ValueError("Found arrays with inconsistent numbers of samples: "
"%s" % str(uniques))
def indexable(*iterables):
"""Make arrays indexable for cross-validation.
Checks consistent length, passes through None, and ensures that everything
can be indexed by converting sparse matrices to csr and converting
non-interable objects to arrays.
Parameters
----------
*iterables : lists, dataframes, arrays, sparse matrices
List of objects to ensure sliceability.
"""
result = []
for X in iterables:
if sp.issparse(X):
result.append(X.tocsr())
elif hasattr(X, "__getitem__") or hasattr(X, "iloc"):
result.append(X)
elif X is None:
result.append(X)
else:
result.append(np.array(X))
check_consistent_length(*result)
return result
def _ensure_sparse_format(spmatrix, accept_sparse, dtype, copy,
force_all_finite):
"""Convert a sparse matrix to a given format.
Checks the sparse format of spmatrix and converts if necessary.
Parameters
----------
spmatrix : scipy sparse matrix
Input to validate and convert.
accept_sparse : string, list of string or None (default=None)
String[s] representing allowed sparse matrix formats ('csc',
'csr', 'coo', 'dok', 'bsr', 'lil', 'dia'). None means that sparse
matrix input will raise an error. If the input is sparse but not in
the allowed format, it will be converted to the first listed format.
dtype : string, type or None (default=none)
Data type of result. If None, the dtype of the input is preserved.
copy : boolean (default=False)
Whether a forced copy will be triggered. If copy=False, a copy might
be triggered by a conversion.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
Returns
-------
spmatrix_converted : scipy sparse matrix.
Matrix that is ensured to have an allowed type.
"""
if accept_sparse in [None, False]:
raise TypeError('A sparse matrix was passed, but dense '
'data is required. Use X.toarray() to '
'convert to a dense numpy array.')
if dtype is None:
dtype = spmatrix.dtype
changed_format = False
if (isinstance(accept_sparse, (list, tuple))
and spmatrix.format not in accept_sparse):
# create new with correct sparse
spmatrix = spmatrix.asformat(accept_sparse[0])
changed_format = True
if dtype != spmatrix.dtype:
# convert dtype
spmatrix = spmatrix.astype(dtype)
elif copy and not changed_format:
# force copy
spmatrix = spmatrix.copy()
if force_all_finite:
if not hasattr(spmatrix, "data"):
warnings.warn("Can't check %s sparse matrix for nan or inf."
% spmatrix.format)
else:
_assert_all_finite(spmatrix.data)
return spmatrix
def check_array(array, accept_sparse=None, dtype="numeric", order=None,
copy=False, force_all_finite=True, ensure_2d=True,
allow_nd=False, ensure_min_samples=1, ensure_min_features=1,
warn_on_dtype=False, estimator=None):
"""Input validation on an array, list, sparse matrix or similar.
By default, the input is converted to an at least 2nd numpy array.
If the dtype of the array is object, attempt converting to float,
raising on failure.
Parameters
----------
array : object
Input object to check / convert.
accept_sparse : string, list of string or None (default=None)
String[s] representing allowed sparse matrix formats, such as 'csc',
'csr', etc. None means that sparse matrix input will raise an error.
If the input is sparse but not in the allowed format, it will be
converted to the first listed format.
dtype : string, type, list of types or None (default="numeric")
Data type of result. If None, the dtype of the input is preserved.
If "numeric", dtype is preserved unless array.dtype is object.
If dtype is a list of types, conversion on the first type is only
performed if the dtype of the input is not in the list.
order : 'F', 'C' or None (default=None)
Whether an array will be forced to be fortran or c-style.
copy : boolean (default=False)
Whether a forced copy will be triggered. If copy=False, a copy might
be triggered by a conversion.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
ensure_2d : boolean (default=True)
Whether to make X at least 2d.
allow_nd : boolean (default=False)
Whether to allow X.ndim > 2.
ensure_min_samples : int (default=1)
Make sure that the array has a minimum number of samples in its first
axis (rows for a 2D array). Setting to 0 disables this check.
ensure_min_features : int (default=1)
Make sure that the 2D array has some minimum number of features
(columns). The default value of 1 rejects empty datasets.
This check is only enforced when the input data has effectively 2
dimensions or is originally 1D and ``ensure_2d`` is True. Setting to 0
disables this check.
warn_on_dtype : boolean (default=False)
Raise DataConversionWarning if the dtype of the input data structure
does not match the requested dtype, causing a memory copy.
estimator : str or estimator instance (default=None)
If passed, include the name of the estimator in warning messages.
Returns
-------
X_converted : object
The converted and validated X.
"""
if isinstance(accept_sparse, str):
accept_sparse = [accept_sparse]
# store whether originally we wanted numeric dtype
dtype_numeric = dtype == "numeric"
dtype_orig = getattr(array, "dtype", None)
if not hasattr(dtype_orig, 'kind'):
# not a data type (e.g. a column named dtype in a pandas DataFrame)
dtype_orig = None
if dtype_numeric:
if dtype_orig is not None and dtype_orig.kind == "O":
# if input is object, convert to float.
dtype = np.float64
else:
dtype = None
if isinstance(dtype, (list, tuple)):
if dtype_orig is not None and dtype_orig in dtype:
# no dtype conversion required
dtype = None
else:
# dtype conversion required. Let's select the first element of the
# list of accepted types.
dtype = dtype[0]
if sp.issparse(array):
array = _ensure_sparse_format(array, accept_sparse, dtype, copy,
force_all_finite)
else:
if ensure_2d:
array = np.atleast_2d(array)
array = np.array(array, dtype=dtype, order=order, copy=copy)
# make sure we actually converted to numeric:
if dtype_numeric and array.dtype.kind == "O":
array = array.astype(np.float64)
if not allow_nd and array.ndim >= 3:
raise ValueError("Found array with dim %d. Expected <= 2" %
array.ndim)
if force_all_finite:
_assert_all_finite(array)
shape_repr = _shape_repr(array.shape)
if ensure_min_samples > 0:
n_samples = _num_samples(array)
if n_samples < ensure_min_samples:
raise ValueError("Found array with %d sample(s) (shape=%s) while a"
" minimum of %d is required."
% (n_samples, shape_repr, ensure_min_samples))
if ensure_min_features > 0 and array.ndim == 2:
n_features = array.shape[1]
if n_features < ensure_min_features:
raise ValueError("Found array with %d feature(s) (shape=%s) while"
" a minimum of %d is required."
% (n_features, shape_repr, ensure_min_features))
if warn_on_dtype and dtype_orig is not None and array.dtype != dtype_orig:
msg = ("Data with input dtype %s was converted to %s"
% (dtype_orig, array.dtype))
if estimator is not None:
if not isinstance(estimator, six.string_types):
estimator = estimator.__class__.__name__
msg += " by %s" % estimator
warnings.warn(msg, DataConversionWarning)
return array
def check_X_y(X, y, accept_sparse=None, dtype="numeric", order=None, copy=False,
force_all_finite=True, ensure_2d=True, allow_nd=False,
multi_output=False, ensure_min_samples=1,
ensure_min_features=1, y_numeric=False,
warn_on_dtype=False, estimator=None):
"""Input validation for standard estimators.
Checks X and y for consistent length, enforces X 2d and y 1d.
Standard input checks are only applied to y. For multi-label y,
set multi_output=True to allow 2d and sparse y.
If the dtype of X is object, attempt converting to float,
raising on failure.
Parameters
----------
X : nd-array, list or sparse matrix
Input data.
y : nd-array, list or sparse matrix
Labels.
accept_sparse : string, list of string or None (default=None)
String[s] representing allowed sparse matrix formats, such as 'csc',
'csr', etc. None means that sparse matrix input will raise an error.
If the input is sparse but not in the allowed format, it will be
converted to the first listed format.
dtype : string, type, list of types or None (default="numeric")
Data type of result. If None, the dtype of the input is preserved.
If "numeric", dtype is preserved unless array.dtype is object.
If dtype is a list of types, conversion on the first type is only
performed if the dtype of the input is not in the list.
order : 'F', 'C' or None (default=None)
Whether an array will be forced to be fortran or c-style.
copy : boolean (default=False)
Whether a forced copy will be triggered. If copy=False, a copy might
be triggered by a conversion.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
ensure_2d : boolean (default=True)
Whether to make X at least 2d.
allow_nd : boolean (default=False)
Whether to allow X.ndim > 2.
multi_output : boolean (default=False)
Whether to allow 2-d y (array or sparse matrix). If false, y will be
validated as a vector.
ensure_min_samples : int (default=1)
Make sure that X has a minimum number of samples in its first
axis (rows for a 2D array).
ensure_min_features : int (default=1)
Make sure that the 2D array has some minimum number of features
(columns). The default value of 1 rejects empty datasets.
This check is only enforced when X has effectively 2 dimensions or
is originally 1D and ``ensure_2d`` is True. Setting to 0 disables
this check.
y_numeric : boolean (default=False)
Whether to ensure that y has a numeric type. If dtype of y is object,
it is converted to float64. Should only be used for regression
algorithms.
warn_on_dtype : boolean (default=False)
Raise DataConversionWarning if the dtype of the input data structure
does not match the requested dtype, causing a memory copy.
estimator : str or estimator instance (default=None)
If passed, include the name of the estimator in warning messages.
Returns
-------
X_converted : object
The converted and validated X.
"""
X = check_array(X, accept_sparse, dtype, order, copy, force_all_finite,
ensure_2d, allow_nd, ensure_min_samples,
ensure_min_features, warn_on_dtype, estimator)
if multi_output:
y = check_array(y, 'csr', force_all_finite=True, ensure_2d=False,
dtype=None)
else:
y = column_or_1d(y, warn=True)
_assert_all_finite(y)
if y_numeric and y.dtype.kind == 'O':
y = y.astype(np.float64)
check_consistent_length(X, y)
return X, y
def column_or_1d(y, warn=False):
""" Ravel column or 1d numpy array, else raises an error
Parameters
----------
y : array-like
warn : boolean, default False
To control display of warnings.
Returns
-------
y : array
"""
shape = np.shape(y)
if len(shape) == 1:
return np.ravel(y)
if len(shape) == 2 and shape[1] == 1:
if warn:
warnings.warn("A column-vector y was passed when a 1d array was"
" expected. Please change the shape of y to "
"(n_samples, ), for example using ravel().",
DataConversionWarning, stacklevel=2)
return np.ravel(y)
raise ValueError("bad input shape {0}".format(shape))
def check_random_state(seed):
"""Turn seed into a np.random.RandomState instance
If seed is None, return the RandomState singleton used by np.random.
If seed is an int, return a new RandomState instance seeded with seed.
If seed is already a RandomState instance, return it.
Otherwise raise ValueError.
"""
if seed is None or seed is np.random:
return np.random.mtrand._rand
if isinstance(seed, (numbers.Integral, np.integer)):
return np.random.RandomState(seed)
if isinstance(seed, np.random.RandomState):
return seed
raise ValueError('%r cannot be used to seed a numpy.random.RandomState'
' instance' % seed)
def has_fit_parameter(estimator, parameter):
"""Checks whether the estimator's fit method supports the given parameter.
Examples
--------
>>> from sklearn.svm import SVC
>>> has_fit_parameter(SVC(), "sample_weight")
True
"""
return parameter in getargspec(estimator.fit)[0]
def check_symmetric(array, tol=1E-10, raise_warning=True,
raise_exception=False):
"""Make sure that array is 2D, square and symmetric.
If the array is not symmetric, then a symmetrized version is returned.
Optionally, a warning or exception is raised if the matrix is not
symmetric.
Parameters
----------
array : nd-array or sparse matrix
Input object to check / convert. Must be two-dimensional and square,
otherwise a ValueError will be raised.
tol : float
Absolute tolerance for equivalence of arrays. Default = 1E-10.
raise_warning : boolean (default=True)
If True then raise a warning if conversion is required.
raise_exception : boolean (default=False)
If True then raise an exception if array is not symmetric.
Returns
-------
array_sym : ndarray or sparse matrix
Symmetrized version of the input array, i.e. the average of array
and array.transpose(). If sparse, then duplicate entries are first
summed and zeros are eliminated.
"""
if (array.ndim != 2) or (array.shape[0] != array.shape[1]):
raise ValueError("array must be 2-dimensional and square. "
"shape = {0}".format(array.shape))
if sp.issparse(array):
diff = array - array.T
# only csr, csc, and coo have `data` attribute
if diff.format not in ['csr', 'csc', 'coo']:
diff = diff.tocsr()
symmetric = np.all(abs(diff.data) < tol)
else:
symmetric = np.allclose(array, array.T, atol=tol)
if not symmetric:
if raise_exception:
raise ValueError("Array must be symmetric")
if raise_warning:
warnings.warn("Array is not symmetric, and will be converted "
"to symmetric by average with its transpose.")
if sp.issparse(array):
conversion = 'to' + array.format
array = getattr(0.5 * (array + array.T), conversion)()
else:
array = 0.5 * (array + array.T)
return array
def check_is_fitted(estimator, attributes, msg=None, all_or_any=all):
"""Perform is_fitted validation for estimator.
Checks if the estimator is fitted by verifying the presence of
"all_or_any" of the passed attributes and raises a NotFittedError with the
given message.
Parameters
----------
estimator : estimator instance.
estimator instance for which the check is performed.
attributes : attribute name(s) given as string or a list/tuple of strings
Eg. : ["coef_", "estimator_", ...], "coef_"
msg : string
The default error message is, "This %(name)s instance is not fitted
yet. Call 'fit' with appropriate arguments before using this method."
For custom messages if "%(name)s" is present in the message string,
it is substituted for the estimator name.
Eg. : "Estimator, %(name)s, must be fitted before sparsifying".
all_or_any : callable, {all, any}, default all
Specify whether all or any of the given attributes must exist.
"""
if msg is None:
msg = ("This %(name)s instance is not fitted yet. Call 'fit' with "
"appropriate arguments before using this method.")
if not hasattr(estimator, 'fit'):
raise TypeError("%s is not an estimator instance." % (estimator))
if not isinstance(attributes, (list, tuple)):
attributes = [attributes]
if not all_or_any([hasattr(estimator, attr) for attr in attributes]):
raise NotFittedError(msg % {'name': type(estimator).__name__})
| bsd-3-clause |
sarahgrogan/scikit-learn | examples/bicluster/plot_spectral_biclustering.py | 403 | 2011 | """
=============================================
A demo of the Spectral Biclustering algorithm
=============================================
This example demonstrates how to generate a checkerboard dataset and
bicluster it using the Spectral Biclustering algorithm.
The data is generated with the ``make_checkerboard`` function, then
shuffled and passed to the Spectral Biclustering algorithm. The rows
and columns of the shuffled matrix are rearranged to show the
biclusters found by the algorithm.
The outer product of the row and column label vectors shows a
representation of the checkerboard structure.
"""
print(__doc__)
# Author: Kemal Eren <[email protected]>
# License: BSD 3 clause
import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import make_checkerboard
from sklearn.datasets import samples_generator as sg
from sklearn.cluster.bicluster import SpectralBiclustering
from sklearn.metrics import consensus_score
n_clusters = (4, 3)
data, rows, columns = make_checkerboard(
shape=(300, 300), n_clusters=n_clusters, noise=10,
shuffle=False, random_state=0)
plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Original dataset")
data, row_idx, col_idx = sg._shuffle(data, random_state=0)
plt.matshow(data, cmap=plt.cm.Blues)
plt.title("Shuffled dataset")
model = SpectralBiclustering(n_clusters=n_clusters, method='log',
random_state=0)
model.fit(data)
score = consensus_score(model.biclusters_,
(rows[:, row_idx], columns[:, col_idx]))
print("consensus score: {:.1f}".format(score))
fit_data = data[np.argsort(model.row_labels_)]
fit_data = fit_data[:, np.argsort(model.column_labels_)]
plt.matshow(fit_data, cmap=plt.cm.Blues)
plt.title("After biclustering; rearranged to show biclusters")
plt.matshow(np.outer(np.sort(model.row_labels_) + 1,
np.sort(model.column_labels_) + 1),
cmap=plt.cm.Blues)
plt.title("Checkerboard structure of rearranged data")
plt.show()
| bsd-3-clause |
datapythonista/pandas | pandas/tests/frame/methods/test_convert_dtypes.py | 2 | 1129 | import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
class TestConvertDtypes:
@pytest.mark.parametrize(
"convert_integer, expected", [(False, np.dtype("int32")), (True, "Int32")]
)
def test_convert_dtypes(self, convert_integer, expected):
# Specific types are tested in tests/series/test_dtypes.py
# Just check that it works for DataFrame here
df = pd.DataFrame(
{
"a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
"b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
}
)
result = df.convert_dtypes(True, True, convert_integer, False)
expected = pd.DataFrame(
{
"a": pd.Series([1, 2, 3], dtype=expected),
"b": pd.Series(["x", "y", "z"], dtype="string"),
}
)
tm.assert_frame_equal(result, expected)
def test_convert_empty(self):
# Empty DataFrame can pass convert_dtypes, see GH#40393
empty_df = pd.DataFrame()
tm.assert_frame_equal(empty_df, empty_df.convert_dtypes())
| bsd-3-clause |
mahak/spark | python/pyspark/sql/tests/test_pandas_map.py | 20 | 4612 | #
# 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 os
import time
import unittest
from pyspark.testing.sqlutils import ReusedSQLTestCase, have_pandas, have_pyarrow, \
pandas_requirement_message, pyarrow_requirement_message
if have_pandas:
import pandas as pd
@unittest.skipIf(
not have_pandas or not have_pyarrow,
pandas_requirement_message or pyarrow_requirement_message) # type: ignore[arg-type]
class MapInPandasTests(ReusedSQLTestCase):
@classmethod
def setUpClass(cls):
ReusedSQLTestCase.setUpClass()
# Synchronize default timezone between Python and Java
cls.tz_prev = os.environ.get("TZ", None) # save current tz if set
tz = "America/Los_Angeles"
os.environ["TZ"] = tz
time.tzset()
cls.sc.environment["TZ"] = tz
cls.spark.conf.set("spark.sql.session.timeZone", tz)
@classmethod
def tearDownClass(cls):
del os.environ["TZ"]
if cls.tz_prev is not None:
os.environ["TZ"] = cls.tz_prev
time.tzset()
ReusedSQLTestCase.tearDownClass()
def test_map_partitions_in_pandas(self):
def func(iterator):
for pdf in iterator:
assert isinstance(pdf, pd.DataFrame)
assert pdf.columns == ['id']
yield pdf
df = self.spark.range(10)
actual = df.mapInPandas(func, 'id long').collect()
expected = df.collect()
self.assertEqual(actual, expected)
def test_multiple_columns(self):
data = [(1, "foo"), (2, None), (3, "bar"), (4, "bar")]
df = self.spark.createDataFrame(data, "a int, b string")
def func(iterator):
for pdf in iterator:
assert isinstance(pdf, pd.DataFrame)
assert [d.name for d in list(pdf.dtypes)] == ['int32', 'object']
yield pdf
actual = df.mapInPandas(func, df.schema).collect()
expected = df.collect()
self.assertEqual(actual, expected)
def test_different_output_length(self):
def func(iterator):
for _ in iterator:
yield pd.DataFrame({'a': list(range(100))})
df = self.spark.range(10)
actual = df.repartition(1).mapInPandas(func, 'a long').collect()
self.assertEqual(set((r.a for r in actual)), set(range(100)))
def test_empty_iterator(self):
def empty_iter(_):
return iter([])
self.assertEqual(
self.spark.range(10).mapInPandas(empty_iter, 'a int, b string').count(), 0)
def test_empty_rows(self):
def empty_rows(_):
return iter([pd.DataFrame({'a': []})])
self.assertEqual(
self.spark.range(10).mapInPandas(empty_rows, 'a int').count(), 0)
def test_chain_map_partitions_in_pandas(self):
def func(iterator):
for pdf in iterator:
assert isinstance(pdf, pd.DataFrame)
assert pdf.columns == ['id']
yield pdf
df = self.spark.range(10)
actual = df.mapInPandas(func, 'id long').mapInPandas(func, 'id long').collect()
expected = df.collect()
self.assertEqual(actual, expected)
def test_self_join(self):
# SPARK-34319: self-join with MapInPandas
df1 = self.spark.range(10)
df2 = df1.mapInPandas(lambda iter: iter, 'id long')
actual = df2.join(df2).collect()
expected = df1.join(df1).collect()
self.assertEqual(sorted(actual), sorted(expected))
if __name__ == "__main__":
from pyspark.sql.tests.test_pandas_map import * # noqa: F401
try:
import xmlrunner # type: ignore[import]
testRunner = xmlrunner.XMLTestRunner(output='target/test-reports', verbosity=2)
except ImportError:
testRunner = None
unittest.main(testRunner=testRunner, verbosity=2)
| apache-2.0 |
ssaeger/scikit-learn | examples/decomposition/plot_pca_vs_lda.py | 176 | 2027 | """
=======================================================
Comparison of LDA and PCA 2D projection of Iris dataset
=======================================================
The Iris dataset represents 3 kind of Iris flowers (Setosa, Versicolour
and Virginica) with 4 attributes: sepal length, sepal width, petal length
and petal width.
Principal Component Analysis (PCA) applied to this data identifies the
combination of attributes (principal components, or directions in the
feature space) that account for the most variance in the data. Here we
plot the different samples on the 2 first principal components.
Linear Discriminant Analysis (LDA) tries to identify attributes that
account for the most variance *between classes*. In particular,
LDA, in contrast to PCA, is a supervised method, using known class labels.
"""
print(__doc__)
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
iris = datasets.load_iris()
X = iris.data
y = iris.target
target_names = iris.target_names
pca = PCA(n_components=2)
X_r = pca.fit(X).transform(X)
lda = LinearDiscriminantAnalysis(n_components=2)
X_r2 = lda.fit(X, y).transform(X)
# Percentage of variance explained for each components
print('explained variance ratio (first two components): %s'
% str(pca.explained_variance_ratio_))
plt.figure()
colors = ['navy', 'turquoise', 'darkorange']
lw = 2
for color, i, target_name in zip(colors, [0, 1, 2], target_names):
plt.scatter(X_r[y == i, 0], X_r[y == i, 1], color=color, alpha=.8, lw=lw,
label=target_name)
plt.legend(loc='best', shadow=False, scatterpoints=1)
plt.title('PCA of IRIS dataset')
plt.figure()
for color, i, target_name in zip(colors, [0, 1, 2], target_names):
plt.scatter(X_r2[y == i, 0], X_r2[y == i, 1], alpha=.8, color=color,
label=target_name)
plt.legend(loc='best', shadow=False, scatterpoints=1)
plt.title('LDA of IRIS dataset')
plt.show()
| bsd-3-clause |
dingocuster/scikit-learn | sklearn/utils/tests/test_multiclass.py | 128 | 12853 |
from __future__ import division
import numpy as np
import scipy.sparse as sp
from itertools import product
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_raises_regex
from sklearn.utils.multiclass import unique_labels
from sklearn.utils.multiclass import is_multilabel
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]])),
],
'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': [
[[]],
[()],
# sequence of sequences that were'nt supported even before deprecation
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'}],
# empty second dimension
np.array([[], []]),
# 3d
np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]),
]
}
NON_ARRAY_LIKE_EXAMPLES = [
set([1, 2, 3]),
{0: 'a', 1: 'b'},
{0: [5], 1: [5]},
'abc',
frozenset([1, 2, 3]),
None,
]
MULTILABEL_SEQUENCES = [
[[1], [2], [0, 1]],
[(), (2), (0, 1)],
np.array([[], [1, 2]], dtype='object'),
NotAnArray(np.array([[], [1, 2]], dtype='object'))
]
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]))
# Multilabel indicator
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))
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-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)
def test_unique_labels_mixed_types():
# Mix with binary or multiclass and multilabel
mix_clf_format = product(EXAMPLES["multilabel-indicator"],
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)
assert_raises(ValueError, unique_labels, [[1, 2]], [["a", "d"]])
assert_raises(ValueError, unique_labels, ["1", 2])
assert_raises(ValueError, unique_labels, [["1", 2], [1, 3]])
assert_raises(ValueError, unique_labels, [["1", "2"], [2, 3]])
def test_is_multilabel():
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_multilabel(exmpl_sparse),
msg=('is_multilabel(%r)'
' should be %s')
% (exmpl_sparse, sparse_exp))
# Densify sparse examples before testing
if issparse(example):
example = example.toarray()
dense_assert_(is_multilabel(example),
msg='is_multilabel(%r) should be %s'
% (example, dense_exp))
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:
msg_regex = 'Expected array-like \(array or non-string sequence\).*'
assert_raises_regex(ValueError, msg_regex, type_of_target, example)
for example in MULTILABEL_SEQUENCES:
msg = ('You appear to be using a legacy multi-label data '
'representation. Sequence of sequences are no longer supported;'
' use a binary array or sparse matrix instead.')
assert_raises_regex(ValueError, msg, 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 |
aflaxman/scikit-learn | sklearn/utils/tests/test_seq_dataset.py | 79 | 2497 | # Author: Tom Dupre la Tour <[email protected]>
#
# License: BSD 3 clause
import numpy as np
from numpy.testing import assert_array_equal
import scipy.sparse as sp
from sklearn.utils.seq_dataset import ArrayDataset, CSRDataset
from sklearn.datasets import load_iris
from sklearn.utils.testing import assert_equal
iris = load_iris()
X = iris.data.astype(np.float64)
y = iris.target.astype(np.float64)
X_csr = sp.csr_matrix(X)
sample_weight = np.arange(y.size, dtype=np.float64)
def assert_csr_equal(X, Y):
X.eliminate_zeros()
Y.eliminate_zeros()
assert_equal(X.shape[0], Y.shape[0])
assert_equal(X.shape[1], Y.shape[1])
assert_array_equal(X.data, Y.data)
assert_array_equal(X.indices, Y.indices)
assert_array_equal(X.indptr, Y.indptr)
def test_seq_dataset():
dataset1 = ArrayDataset(X, y, sample_weight, seed=42)
dataset2 = CSRDataset(X_csr.data, X_csr.indptr, X_csr.indices,
y, sample_weight, seed=42)
for dataset in (dataset1, dataset2):
for i in range(5):
# next sample
xi_, yi, swi, idx = dataset._next_py()
xi = sp.csr_matrix((xi_), shape=(1, X.shape[1]))
assert_csr_equal(xi, X_csr[idx])
assert_equal(yi, y[idx])
assert_equal(swi, sample_weight[idx])
# random sample
xi_, yi, swi, idx = dataset._random_py()
xi = sp.csr_matrix((xi_), shape=(1, X.shape[1]))
assert_csr_equal(xi, X_csr[idx])
assert_equal(yi, y[idx])
assert_equal(swi, sample_weight[idx])
def test_seq_dataset_shuffle():
dataset1 = ArrayDataset(X, y, sample_weight, seed=42)
dataset2 = CSRDataset(X_csr.data, X_csr.indptr, X_csr.indices,
y, sample_weight, seed=42)
# not shuffled
for i in range(5):
_, _, _, idx1 = dataset1._next_py()
_, _, _, idx2 = dataset2._next_py()
assert_equal(idx1, i)
assert_equal(idx2, i)
for i in range(5):
_, _, _, idx1 = dataset1._random_py()
_, _, _, idx2 = dataset2._random_py()
assert_equal(idx1, idx2)
seed = 77
dataset1._shuffle_py(seed)
dataset2._shuffle_py(seed)
for i in range(5):
_, _, _, idx1 = dataset1._next_py()
_, _, _, idx2 = dataset2._next_py()
assert_equal(idx1, idx2)
_, _, _, idx1 = dataset1._random_py()
_, _, _, idx2 = dataset2._random_py()
assert_equal(idx1, idx2)
| bsd-3-clause |
mjgrav2001/scikit-learn | examples/mixture/plot_gmm_selection.py | 248 | 3223 | """
=================================
Gaussian Mixture Model Selection
=================================
This example shows that model selection can be performed with
Gaussian Mixture Models using information-theoretic criteria (BIC).
Model selection concerns both the covariance type
and the number of components in the model.
In that case, AIC also provides the right result (not shown to save time),
but BIC is better suited if the problem is to identify the right model.
Unlike Bayesian procedures, such inferences are prior-free.
In that case, the model with 2 components and full covariance
(which corresponds to the true generative model) is selected.
"""
print(__doc__)
import itertools
import numpy as np
from scipy import linalg
import matplotlib.pyplot as plt
import matplotlib as mpl
from sklearn import mixture
# Number of samples per component
n_samples = 500
# Generate random sample, two components
np.random.seed(0)
C = np.array([[0., -0.1], [1.7, .4]])
X = np.r_[np.dot(np.random.randn(n_samples, 2), C),
.7 * np.random.randn(n_samples, 2) + np.array([-6, 3])]
lowest_bic = np.infty
bic = []
n_components_range = range(1, 7)
cv_types = ['spherical', 'tied', 'diag', 'full']
for cv_type in cv_types:
for n_components in n_components_range:
# Fit a mixture of Gaussians with EM
gmm = mixture.GMM(n_components=n_components, covariance_type=cv_type)
gmm.fit(X)
bic.append(gmm.bic(X))
if bic[-1] < lowest_bic:
lowest_bic = bic[-1]
best_gmm = gmm
bic = np.array(bic)
color_iter = itertools.cycle(['k', 'r', 'g', 'b', 'c', 'm', 'y'])
clf = best_gmm
bars = []
# Plot the BIC scores
spl = plt.subplot(2, 1, 1)
for i, (cv_type, color) in enumerate(zip(cv_types, color_iter)):
xpos = np.array(n_components_range) + .2 * (i - 2)
bars.append(plt.bar(xpos, bic[i * len(n_components_range):
(i + 1) * len(n_components_range)],
width=.2, color=color))
plt.xticks(n_components_range)
plt.ylim([bic.min() * 1.01 - .01 * bic.max(), bic.max()])
plt.title('BIC score per model')
xpos = np.mod(bic.argmin(), len(n_components_range)) + .65 +\
.2 * np.floor(bic.argmin() / len(n_components_range))
plt.text(xpos, bic.min() * 0.97 + .03 * bic.max(), '*', fontsize=14)
spl.set_xlabel('Number of components')
spl.legend([b[0] for b in bars], cv_types)
# Plot the winner
splot = plt.subplot(2, 1, 2)
Y_ = clf.predict(X)
for i, (mean, covar, color) in enumerate(zip(clf.means_, clf.covars_,
color_iter)):
v, w = linalg.eigh(covar)
if not np.any(Y_ == i):
continue
plt.scatter(X[Y_ == i, 0], X[Y_ == i, 1], .8, color=color)
# Plot an ellipse to show the Gaussian component
angle = np.arctan2(w[0][1], w[0][0])
angle = 180 * angle / np.pi # convert to degrees
v *= 4
ell = mpl.patches.Ellipse(mean, v[0], v[1], 180 + angle, color=color)
ell.set_clip_box(splot.bbox)
ell.set_alpha(.5)
splot.add_artist(ell)
plt.xlim(-10, 10)
plt.ylim(-3, 6)
plt.xticks(())
plt.yticks(())
plt.title('Selected GMM: full model, 2 components')
plt.subplots_adjust(hspace=.35, bottom=.02)
plt.show()
| bsd-3-clause |
tjlane/thor | src/python/plot.py | 1 | 4165 |
"""
A library for plotting pretty images of all kinds.
"""
import logging
logging.basicConfig()
logger = logging.getLogger(__name__)
import numpy as np
import matplotlib.pyplot as plt
class InteractiveImshow(object):
"""
A brief extension to matplotlib's imshow that puts a colorbar next to
the image that you can click on to scale the maximum numeric value
displayed.
Based on code from pyana_misc by Ingrid Ofte.
Parameters
----------
inarr : np.ndarray
The array to imshow()
filename : {str, None}
The filename to call the file if it is saved. If `None`, disable saving
ability.
"""
def __init__(self, inarr, filename=None, fig=None, ax=None):
"""
Parameters
----------
inarr : np.ndarray
The array to imshow()
filename : {str, None}
The filename to call the file if it is saved. If `None`, disable saving
ability.
fig : pyplot.figure
A figure object to draw on.
ax : pyplot.axes
An axes canvas to draw on.
"""
self.inarr = inarr
self.filename = filename
self.fig = fig
self.ax = ax
self.cmax = self.inarr.max()
self.cmin = self.inarr.min()
self._draw_img()
def _on_keypress(self, event):
if event.key == 's':
if not self.filename:
self.filename = input('Saving. Enter filename: ')
plt.savefig(self.filename)
logger.info("Saved image: %s" % self.filename)
elif event.key == 'r':
logger.info("Reset plot")
colmin, colmax = self.orglims
plt.clim(colmin, colmax)
plt.draw()
def _on_click(self, event):
if event.inaxes:
lims = self.im.get_clim()
colmin = lims[0]
colmax = lims[1]
rng = colmax - colmin
value = colmin + event.ydata * rng
if event.button is 1:
if value > colmin and value < colmax :
colmax = value
elif event.button is 2:
colmin, colmax = self.orglims
elif event.button is 3:
if value > colmin and value < colmax:
colmix = value
self.im.set_clim(colmin, colmax)
plt.draw()
def _on_scroll(self, event):
lims = self.im.get_clim()
speed = 1.1
if event.button == 'up':
colmax = lims[1] / speed
elif event.button == 'down':
colmax = lims[1] * speed
self.im.set_clim(lims[0], colmax)
plt.draw()
def _draw_img(self):
if not self.fig:
self.fig = plt.figure()
cid1 = self.fig.canvas.mpl_connect('key_press_event', self._on_keypress)
cid2 = self.fig.canvas.mpl_connect('button_press_event', self._on_click)
cid3 = self.fig.canvas.mpl_connect('scroll_event', self._on_scroll)
if not self.ax:
self.ax = self.fig.add_subplot(111)
self.im = self.ax.imshow(self.inarr, vmax=self.cmax, origin='lower')
self.colbar = plt.colorbar(self.im, pad=0.01)
self.orglims = self.im.get_clim()
def plot_polar_intensities(shot, output_file=None):
"""
Plot an intensity map in polar coordinates.
Parameters
----------
shot : thor.xray.Shot
A shot to plot.
output_file : str
The filename to write. If `None`, will display the image on screen and
not save.
"""
pi = shot.polar_grid
colors = shot.polar_intensities # color by intensity
ax = plt.subplot(111, polar=True)
c = plt.scatter(pi[:,1], pi[:,0], c=colors, cmap=cm.hsv)
c.set_alpha(0.75)
if output_file:
plt.savefig(output_file)
logger.info("Saved: %s" % output_file)
else:
plt.show()
return | gpl-2.0 |
ScienceStacks/SciSheets | mysite/scisheets/core/table.py | 2 | 27421 | '''
Implements the table class for SciSheets.
'''
from mysite import settings
import CommonUtil.util as ut
from Files.data_capture import DataCapture
from FileVersion.versioned_file import VersionedFile
from helpers.formula_statement import FormulaStatement
from CommonUtil.is_null import isNull
from column import Column
from column_container import ColumnContainer
from table_evaluator import TableEvaluator
from helpers.serialize_deserialize import deserialize
import errors as er
import json
import numpy as np
import os
import pandas as pd
import random
NAME_COLUMN_STR = "row"
NAME_COLUMN_IDX = 0
CUR_DIR = os.path.dirname(__file__)
PROLOGUE_FILEPATH = os.path.join(CUR_DIR, "table.prologue")
EPILOGUE_FILEPATH = os.path.join(CUR_DIR,"table.epilogue")
PROLOGUE_NAME = "Prologue"
EPILOGUE_NAME = "Epilogue"
class Row(dict):
"""
Container of values for a row
"""
pass
# pylint: disable=R0904
class Table(ColumnContainer):
"""
Implements full table functionality.
Feature 1: Maintains consistency
between columns as to column lengths
column names are unique
Feature 2: Knows about rows
add rows
delete rows
rows have a name as specified in the row column
The primary object for referencing a column is the column object.
The primary object for referencing a row is the row index
"""
def __init__(self, name):
super(Table, self).__init__(name)
self._namespace = {} # Namespace for formula evaluation
self._createNameColumn()
if self.getParent() is None:
self._prologue = self._formulaStatementFromFile(PROLOGUE_FILEPATH,
PROLOGUE_NAME)
self._epilogue = self._formulaStatementFromFile(EPILOGUE_FILEPATH,
EPILOGUE_NAME)
else:
self._prologue = None
self._epilogue = None
self._is_evaluate_formulas = True
@classmethod
def createRandomTable(cls, name, nrow, ncol, ncolstr=0,
low_int=0, hi_int=100, table_cls=None):
"""
Creates a table with random integers as values
Input: name - name of the table
nrow - number of rows
ncol - number of columns
ncolstr - number of columns with strings
low_int - smallest integer
hi_int - largest integer
table_cls - Table class to use; default is Table
"""
if table_cls is None:
table_cls = cls
ncol = int(ncol)
nrow = int(nrow)
table = cls(name)
ncolstr = min(ncol, ncolstr)
ncolint = ncol - ncolstr
c_list = range(ncol)
random.shuffle(c_list)
for n in range(ncol):
column = Column("Col_" + str(n))
if c_list[n] <= ncolint - 1:
values = np.random.randint(low_int, hi_int, nrow)
values_ext = values.tolist()
else:
values_ext = ut.randomWords(nrow)
#values_ext.append(None)
column.addCells(np.array(values_ext))
table.addColumn(column)
table.setFilepath(settings.SCISHEETS_DEFAULT_TABLEFILE)
return table
@classmethod
def createRandomHierarchicalTable(cls, name, nrow, num_nodes,
prob_child, ncolstr=0, low_int=0, hi_int=100, prob_detach=0,
table_cls=None):
"""
Creates a table with random integers as values
:param str name: name of the table
:param int nrow: number of rows
:param float prob_child: probability that next node is a child
:param str ncolstr: number of columns with strings
:param int low_int: smallest integer
:param int hi_int: largest integer
:param float prob_detach: probability that a subtree is detached
:parm Type table_cls: Table class to use; default is Table
:return table_cls:
"""
if table_cls is None:
table_cls = cls
# Create the schema for the Hierarchical Table
htable = super(Table, cls).createRandomNamedTree(num_nodes,
prob_child, leaf_cls=Column, prob_detach=prob_detach,
nonleaf_cls=table_cls)
leaves = [c for c in htable.getLeaves()
if c.getName(is_global_name=False) != NAME_COLUMN_STR]
num_leaves = len(htable.getLeaves()) -1 # Don't include the name column
# Create the values for the leaves of the Hierarchical Table
flat_table = Table.createRandomTable(name, nrow, num_leaves, ncolstr=ncolstr,
low_int=low_int, hi_int=hi_int, table_cls=table_cls)
data_columns = flat_table.getDataColumns()
pairs = zip(leaves, data_columns)
# Populate the leaves of the Hierarchical Table
[l.getParent().addCells(l, d.getCells(), replace=True) for l, d in pairs]
# Validate the table
if NAME_COLUMN_STR in \
[n.getName(is_global_name=False) for n in htable.getNonLeaves()]:
import pdb; pdb.set_trace()
htable.setFilepath(settings.SCISHEETS_DEFAULT_TABLEFILE)
return htable
def getSerializationDict(self, class_variable):
"""
:param str class_variable: key to use for the class name
:return dict: dictionary encoding the Table object and its columns
"""
serialization_dict = {}
serialization_dict[class_variable] = str(self.__class__)
filepath = self.getFilepath()
if self.getFilepath() is not None:
if ut.getFileExtension(self.getFilepath()) != settings.SCISHEETS_EXT:
filepath = ut.changeFileExtension(self.getFilepath(),
settings.SCISHEETS_EXT)
more_dict = {
"_name": self.getName(is_global_name=False),
"_prologue_formula": self.getPrologue().getFormula(),
"_epilogue_formula": self.getEpilogue().getFormula(),
"_is_evaluate_formulas": self.getIsEvaluateFormulas(),
"_filepath": filepath,
"_attached": self.isAttached(),
}
serialization_dict.update(more_dict)
_children = []
for child in self.getChildren():
if not Table.isNameColumn(child):
_children.append(child.getSerializationDict(class_variable))
serialization_dict["_children"] = _children
return serialization_dict
@classmethod
def deserialize(cls, serialization_dict, instance=None):
"""
Deserializes a table object and does fix ups.
:param dict serialization_dict: container of parameters for deserialization
:return Table:
"""
if instance is None:
table = Table(serialization_dict["_name"])
else:
table = instance
if serialization_dict["_filepath"] is not None:
table.setFilepath(serialization_dict["_filepath"])
table.setPrologue(serialization_dict["_prologue_formula"])
table.setEpilogue(serialization_dict["_epilogue_formula"])
table.setIsEvaluateFormulas(serialization_dict["_is_evaluate_formulas"])
if "_attached" in serialization_dict.keys():
table.setIsAttached(serialization_dict["_attached"])
if "_children" in serialization_dict.keys():
child_dicts = serialization_dict["_children"]
elif "_columns" in serialization_dict.keys():
child_dicts = serialization_dict["_columns"]
else:
raise ValueError("Cannot find children for %s" % table.getName())
for child_dict in child_dicts:
# Handle older serializations
if not child_dict['_name'] == NAME_COLUMN_STR:
new_child = deserialize(json.dumps(child_dict))
table.addChild(new_child)
table.adjustColumnLength()
return table
# The following methods are used in debugging
def d(self):
return [(c.getName(), c.getCells()) for c
in self.getLeaves()]
def f(self):
return [(c.getName(), c.getFormula())
for c in self.getColumns(is_attached=False)]
def setCapture(self, filename, data):
dc = DataCapture(filename)
dc.setData(data)
def getIsEvaluateFormulas(self):
return self._is_evaluate_formulas
# Internal and other methods
# TODO: Tests with multiple levels of subtable
def _updateNameColumn(self, nrows_table=None):
"""
Changes the cells in the name column of the table
to be consecutive ints.
:paam int nrows_table: Number of rows in the table
"""
if nrows_table is None:
nrows_table = self.numRows()
names = []
for row_num in range(nrows_table):
names.append(Table._rowNameFromIndex(row_num))
for column in self.getLeaves(is_attached=True):
if Table.isNameColumn(column):
column.addCells(list(names), replace=True)
def _formulaStatementFromFile(self, filepath, name):
"""
Reads the file contents and creates the FormulaStatement object.
:param str filepath: path to file to read
:param str name: name of the formula
:returns str: file contents
"""
with open(filepath, 'r') as f:
lines = f.readlines()
statements = ''.join(lines)
return FormulaStatement(statements, name)
# Data columns are those that have user data. The "row" column is excluded.
def getDataColumns(self, is_recursive=True, is_attached=True):
"""
Returns the columns other than the name column
"""
return [c for c in self.getColumns(is_recursive=is_recursive,
is_attached=is_attached) if not Table.isNameColumn(c)]
def getNameColumn(self):
"""
Gets the name column for this table.
:return Column:
"""
columns = [c for c in self.getColumns()
if Table.isNameColumn(c) and c.getParent() == self]
if len(columns) != 1:
raise RuntimeError("Should have exactly one name column")
return columns[0]
def getData(self):
"""
:return dict: keys are global column names
"""
return {c.getName(): list(c.getCells()) for c in self.getColumns()
if not Table.isNameColumn(c)}
def getEpilogue(self):
"""
:return FormulaStatement:
"""
return self._epilogue
def getFormulaColumns(self):
"""
:return list-of-Column:
"""
result = [c for c in self.getColumns(is_attached=False)
if c.getFormula() is not None]
return result
def getRow(self, row_index=None):
"""
:param row_index: row desired
if None, then a row of None is returned
:return: Row object
"""
row = Row()
for column in self.getColumns():
if row_index is None:
if column.isFloats():
row[column.getName()] = np.nan # pylint: disable=E1101
else:
row[column.getName()] = None
else:
row[column.getName()] = column.getCells()[row_index]
return row
def getNamespace(self):
return self._namespace
def getPrologue(self):
"""
:return FormulaStatement:
"""
return self._prologue
# TODO: Verify the index
@staticmethod
def _rowNameFromIndex(index):
"""
Create the row name from its index
"""
return str(index + 1)
def _coerceNameColumnToStr(self):
"""
Makes sure that row names are strings
"""
column = self.columnFromName(NAME_COLUMN_STR, is_relative=False)
if column is None:
import pdb; pdb.set_trace()
values = [str(v) for v in column.getCells()]
column.replaceCells(values)
# TODO: Verify the index
@staticmethod
def _rowNamesFromSize(size):
"""
:param size: number of rows
:return: array of names
"""
return [str(n) for n in range(1, size+1)]
def _createNameColumn(self):
"""
Creates the name column for the table
"""
column = Column(NAME_COLUMN_STR, asis=True)
self.addColumn(column)
def adjustColumnLength(self):
"""
Inserts values of None or np.nan so that column
has the same length as the table
"""
none_array = np.array([None])
num_rows = self.numRows()
for column in self.getColumns():
adj_rows = num_rows - column.numCells()
if adj_rows > 0:
if column.isFloats():
column.addCells(np.repeat(np.nan, adj_rows)) # pylint:disable=E1101
else:
column.addCells(np.repeat(none_array, adj_rows))
self._updateNameColumn(nrows_table=num_rows)
def _validateTable(self):
"""
Checks that the table is internally consistent
Verify that there is at least one column
"""
if len(self.getColumns()) < 1:
raise er.InternalError("Table %s has no columns." % self._name)
# Verify that all columns have the same number of cells
try:
name_column = [c for c in self.getChildren()
if c.getName(is_global_name=False) == NAME_COLUMN_STR][0]
except Exception as e:
import pdb; pdb.set_trace()
if name_column is None:
import pdb; pdb.set_trace()
num_rows = self.numRows()
for column in self.getColumns():
if column.numCells() != num_rows:
import pdb; pdb.set_trace()
msg = "In Table %s, Column %s differs in its number of rows." \
% (self.getName(), column.getName())
raise er.InternalError(msg)
# Verify that the first Column is the Name Column
if self.getChildAtPosition(0).getName(is_global_name=False) != NAME_COLUMN_STR:
msg = "In Table %s, first column is not 'row' column" % self.getName()
raise er.InternalError(msg)
# Verify that names are unique
if self.validateTree() is not None:
raise RuntimeError(self.validateTree())
# Verify the sequence of row names
for nrow in range(self.numRows()):
expected_row_name = Table._rowNameFromIndex(nrow)
actual_row_name = \
self.getChildAtPosition(NAME_COLUMN_IDX).getCells()[nrow]
if actual_row_name != expected_row_name:
import pdb; pdb.set_trace()
msg = "In Table %s, invalid row name at index %d: %s" % \
(self.getName(), nrow, actual_row_name)
raise er.InternalError(msg)
# Verify that the name columns are identical
for column in self.getColumns():
if Table.isNameColumn(column):
if not column.getCells() == name_column.getCells():
raise RuntimeError("%s is not a consistent name column" % column.getName())
def addCells(self, column, cells, replace=False):
"""
Adds to the column
:param Column column:
:param list cells:
"""
column.addCells(cells, replace=replace)
self.adjustColumnLength()
self._validateTable()
def addColumn(self, column, index=None):
"""
Adds a column to the table.
Adjusts the Column length to that of the table
:param column: column object
:param int index: position for the new column
:return: error text if there is a problem with the column
None if no problem
Notes: (1) A new column may have either no cells
or the same number as the existing table
"""
error = None
# Check for problems with this column
is_ok = all([c.getName(is_global_name=False)
!= column.getName(is_global_name=False)
for c in self.getChildren()])
if not is_ok:
error = "**%s is a duplicate name" % column.getName()
return error
else:
error = Column.isPermittedName( \
column.getName(is_global_name=False))
if error is not None:
return error
if index is None:
index = len(self.getColumns(is_attached=False))
# Handle the different cases of adding a column
self.addChild(column, position=index)
# Case 1: First column after name column
if self.numColumns() == 1:
self._updateNameColumn()
# Case 2: Subsequent columns
else:
self.adjustColumnLength()
self._validateTable()
def addRow(self, row, row_index=None):
"""
:param Row row: Row to add
:param int row_index: index where Row is added, may be a float
if None, then appended
"""
# Determine the actual desired name
if row_index is None:
proposed_name = Table._rowNameFromIndex(self.numRows())
else:
proposed_name = Table._rowNameFromIndex(row_index)
# Assign values to the last row of each column cells
for column in self.getColumns():
if column.getName(is_global_name=False) != NAME_COLUMN_STR:
cur_name = column.getName()
if cur_name in row:
column.insertCell(row[cur_name])
else:
column.insertCell(None)
else:
column.insertCell(None)
last_index = self.numRows() - 1
self.renameRow(last_index, proposed_name) # put the row in the right place
self._validateTable()
def copy(self, instance=None):
"""
Returns a copy of this object
:param Table instance:
"""
# Create an object if none provided
if instance is None:
instance = Table(self.getName(is_global_name=False))
name_column = instance.columnFromName(NAME_COLUMN_STR,
is_relative=False)
name_column.removeTree() # Avoid duplicate
# Copy everything required from inherited classes
super(Table, self).copy(instance=instance)
instance._coerceNameColumnToStr()
# Set properties specific to this class
instance.setPrologue(self.getPrologue().getFormula())
instance.setEpilogue(self.getEpilogue().getFormula())
instance.setIsEvaluateFormulas(self.getIsEvaluateFormulas())
self.adjustColumnLength()
return instance
def deleteRows(self, indicies):
"""
Deletes rows
:param indicies: index of rows to delete
"""
indicies.sort()
indicies.reverse()
for column in self.getColumns():
column.deleteCells(indicies)
self._updateNameColumn()
def export(self, **kwargs):
"""
Exports the table to a python program
:return: error - string from the file export
"""
table_evaluator = TableEvaluator(self)
error = table_evaluator.export(**kwargs)
return error
def evaluate(self, user_directory=None):
"""
Evaluates formulas in the table
:param user_directory: full directory path where user modules
are placed
:return: error from table evaluation or None
"""
evaluator = TableEvaluator(self)
error = evaluator.evaluate(user_directory=user_directory)
return error
def isColumnPresent(self, column_name):
"""
:param str column_name: local column name
:return bool: True if column is present
"""
return any([c.getName(is_global_name=False) == column_name
for c in self.getColumns(is_attached=False)])
def isEquivalent(self, other_table, is_exception=False):
"""
Checks that the tables have the same values of their properties,
excluding the VersionedFile.
:param Table other_table:
:param bool is_exception: generate an AssertionError if false
:returns bool:
"""
msg = None
if not isinstance(other_table, self.__class__):
msg = "Table is not equivalent to a non-table."
elif not (self.getName(is_global_name=False) == other_table.getName(is_global_name=False)):
msg = "Table has a different name."
elif not (self.numColumns() == other_table.numColumns()):
msg = "Table has a different number of columns."
elif not (self.getPrologue().isEquivalent(other_table.getPrologue())):
msg = "Table has a different Prologue."
elif not (self.getEpilogue().isEquivalent(other_table.getEpilogue())):
msg = "Table has a different Epilogue."
elif not super(Table, self).isEquivalent(other_table,
is_exception=is_exception):
msg = "Differs because of ancestor of Table."
if msg is None:
return True
elif is_exception:
raise AssertionError(msg)
else:
return False
@staticmethod
def isNameColumn(column):
"""
Determines if this is a name column
:param Column column:
:return bool: True if name column
"""
path = column.pathFromGlobalName(column.getName())
return path[-1] == NAME_COLUMN_STR
@classmethod
def isTable(cls, child):
"""
:param NamedTree child:
:return bool: True if is a Column
"""
return isinstance(child, Table)
def insertRow(self, row, index=None):
"""
Inserts the row in the desired index in the table and
assigns the value of the NAME_COLUMN
:param row: a Row
:param index: index in the table where the row is inserted
"""
idx = index
if idx is None:
idx = self.numRows()
for child in self.getLeaves(is_attached=True):
if ColumnContainer.isColumn(child):
name = child.getName(is_global_name=False)
if name in row.keys():
child.insertCell(row[name], idx)
else:
child.insertCell(None, idx)
self._updateNameColumn()
def moveRow(self, index1, index2):
"""
Moves the row at index1 to index2
"""
row = self.getRow(row_index=index1)
self.deleteRows([index1])
self.insertRow(row, index2)
self._updateNameColumn()
def numRows(self):
"""
Returns the number of rows in the table
"""
attached_leaves = self.getAttachedNodes(self.getColumns())
return max([c.numCells() for c in attached_leaves])
# TODO: This won't work with nested columns
def refactorColumn(self, cur_colnm, new_colnm):
"""
Changes the column name and its occurrences in formulas in the table.
:param str cur_colnm: Current name of the column
:param str new_colnm: New name of the column
:returns list-of-str changed_columns:
:raises ValueError: column name is unknown
"""
def changeFormula(formula_statement):
"""
Changes the formula by replacing occurrences of
cur_colnm with new_colnm
:param FormulaStatement formula_satement:
:returns str/None: new formula or None
"""
formula = formula_statement.getFormula()
if cur_colnm in formula:
return formula.replace(cur_colnm, new_colnm)
else:
return None
column = self.childFromName(cur_colnm, is_relative=True)
if column is None:
raise ValueError("Column %s does not exist." % cur_colnm)
column.setName(new_colnm)
columns = self.getColumns(is_attached=False)
changed_columns = []
try:
# Do the Columns
for col in self.getFormulaColumns():
new_formula = changeFormula(col.getFormulaStatementObject())
if new_formula is not None:
col.setFormula(new_formula)
changed_columns.append(col.getName())
# Handle Prologue
new_formula = changeFormula(self.getPrologue())
if new_formula is not None:
self.setPrologue(new_formula)
changed_columns.append(PROLOGUE_NAME)
# Handle Epilogue
new_formula = changeFormula(self.getEpilogue())
if new_formula is not None:
self.setEpilogue(new_formula)
changed_columns.append(PROLOGUE_NAME)
except Exception as err:
msg = '''Changing column name from %s to %s.
Encountered error %s.
Changed formulas in columns %s.''' % (cur_colnm, new_colnm,
str(err), ' '.join(changed_columns))
return changed_columns
@staticmethod
def rowIndexFromName(name):
"""
Returns the row index for the row name
"""
return int(name) - 1
def renameColumn(self, column, proposed_name):
"""
Renames the column, checking for a duplicate
:param column: column object
:param proposed_name: str, proposed name
:return: Boolean indicating success or failure
"""
names = [c.getName(is_global_name=False) for c in self.getChildren()]
bool_test = all([name != proposed_name for name in names])
if bool_test:
column.setName(proposed_name)
return bool_test
def renameRow(self, row_index, proposed_name):
"""
Renames the row so that it is an integer value
that creates the row ordering desired.
:param row_index: index of the row to change
:param proposed_name: string of a number
"""
name_column = self.childFromName(NAME_COLUMN_STR,
is_relative=True)
names = name_column.getCells()
try:
names[row_index] = str(proposed_name)
except:
import pdb; pdb.set_trace()
try:
float_names = [float(x) for x in names]
except:
import pdb; pdb.set_trace()
sel_index = np.argsort(float_names)
new_names = Table._rowNamesFromSize(len(names))
for column in self.getChildren(is_recursive=True):
if Table.isNameColumn(column):
column.replaceCells(list(new_names))
self._updateNameColumn()
# Update the order of values in each column
for column in self.getLeaves(is_attached=True):
if not Table.isNameColumn(column):
data = column.getCells()
new_data = [data[n] for n in sel_index]
column.replaceCells(new_data)
def setNamespace(self, namespace):
self._namespace = namespace
def setIsEvaluateFormulas(self, setting):
self._is_evaluate_formulas = setting
def setEpilogue(self, epilogue_formula):
"""
:param str epilogue_formula: New value for the Epilogue formula
:return str: Error or None
"""
self._epilogue = FormulaStatement(epilogue_formula, EPILOGUE_NAME)
return self._epilogue.do()
def setPrologue(self, prologue_formula):
"""
:param str prologue_formula: New value for the Prologue formula
"""
self._prologue = FormulaStatement(prologue_formula, PROLOGUE_NAME)
return self._prologue.do()
def tableFromName(self, name, is_relative=True):
"""
Finds the table with the specified name or None.
Note that Columns must be leaves in the Tree.
:param str name: name of the column
:return NamedTree:
"""
leaf = self.childFromName(name, is_relative=is_relative)
if Table.isTable(leaf):
return leaf
def trimRows(self):
"""
Removes all consequative rows at the end of the table
that have None values in the data columns
"""
num_rows = self.numRows()
row_indexes = range(num_rows)
row_indexes.sort(reverse=True)
for index in row_indexes:
row = self.getRow(row_index=index)
# Delete all of the name columns
for colnm in row.keys():
column = self.childFromName(colnm, is_relative=False)
if column is None:
import pdb; pdb.set_trace()
if Table.isNameColumn(column):
del row[column.getName()]
delete_row = True
for name in row.keys():
column = self.childFromName(name, is_relative=False)
if not isNull(row[name]):
delete_row = False
if delete_row:
self.deleteRows([index])
else:
break
def updateCell(self, value, row_index, column_id):
"""
Changes the value of the identified cell
:param obj value: new value for the cell
:param int row_index: 0-based index of the row
:param int/str column_id: 0-based index of the column or its name
"""
if isinstance(column_id, int):
column = self.columnFromIndex(column_id)
else:
column = self.childFromName(column_id, is_relative=False)
column.updateCell(value, row_index)
def updateColumn(self, column, cells):
"""
Replaces the cells in the column with those provided
:param column: column to update
:param cells: cells to change
"""
column.addCells(cells, replace=True)
self.adjustColumnLength()
self._validateTable()
def updateRow(self, row, index):
"""
Updates the row in place. Only changes values
Assigns the value of the NAME_COLUMN
that are specified in row.
:param row: Row
:param index: index of row to change
"""
row[NAME_COLUMN_STR] = Table._rowNameFromIndex(index)
for name in row:
column = self.childFromName(name, is_relative=False)
if not Table.isNameColumn(column):
column.updateCell(row[name], index)
self.adjustColumnLength()
| apache-2.0 |
dpgoetz/swift | swift/common/middleware/x_profile/html_viewer.py | 15 | 21038 | # Copyright (c) 2010-2012 OpenStack, LLC.
#
# 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 cgi
import os
import random
import re
import string
import tempfile
from swift import gettext_ as _
from exceptions import PLOTLIBNotInstalled, ODFLIBNotInstalled,\
NotFoundException, MethodNotAllowed, DataLoadFailure, ProfileException
from profile_model import Stats2
PLOTLIB_INSTALLED = True
try:
import matplotlib
# use agg backend for writing to file, not for rendering in a window.
# otherwise some platform will complain "no display name and $DISPLAY
# environment variable"
matplotlib.use('agg')
import matplotlib.pyplot as plt
except ImportError:
PLOTLIB_INSTALLED = False
empty_description = """
The default profile of current process or the profile you requested is
empty. <input type="submit" name="refresh" value="Refresh"/>
"""
profile_tmpl = """
<select name="profile">
<option value="current">current</option>
<option value="all">all</option>
${profile_list}
</select>
"""
sort_tmpl = """
<select name="sort">
<option value="time">time</option>
<option value="cumulative">cumulative</option>
<option value="calls">calls</option>
<option value="pcalls">pcalls</option>
<option value="name">name</option>
<option value="file">file</option>
<option value="module">module</option>
<option value="line">line</option>
<option value="nfl">nfl</option>
<option value="stdname">stdname</option>
</select>
"""
limit_tmpl = """
<select name="limit">
<option value="-1">all</option>
<option value="0.1">10%</option>
<option value="0.2">20%</option>
<option value="0.3">30%</option>
<option value="10">10</option>
<option value="20">20</option>
<option value="30">30</option>
<option value="50">50</option>
<option value="100">100</option>
<option value="200">200</option>
<option value="300">300</option>
<option value="400">400</option>
<option value="500">500</option>
</select>
"""
fulldirs_tmpl = """
<input type="checkbox" name="fulldirs" value="1"
${fulldir_checked}/>
"""
mode_tmpl = """
<select name="mode">
<option value="stats">stats</option>
<option value="callees">callees</option>
<option value="callers">callers</option>
</select>
"""
nfl_filter_tmpl = """
<input type="text" name="nfl_filter" value="${nfl_filter}"
placeholder="filename part" />
"""
formelements_tmpl = """
<div>
<table>
<tr>
<td>
<strong>Profile</strong>
<td>
<strong>Sort</strong>
</td>
<td>
<strong>Limit</strong>
</td>
<td>
<strong>Full Path</strong>
</td>
<td>
<strong>Filter</strong>
</td>
<td>
</td>
<td>
<strong>Plot Metric</strong>
</td>
<td>
<strong>Plot Type</strong>
<td>
</td>
<td>
<strong>Format</strong>
</td>
<td>
<td>
</td>
<td>
</td>
</tr>
<tr>
<td>
${profile}
<td>
${sort}
</td>
<td>
${limit}
</td>
<td>
${fulldirs}
</td>
<td>
${nfl_filter}
</td>
<td>
<input type="submit" name="query" value="query"/>
</td>
<td>
<select name='metric'>
<option value='nc'>call count</option>
<option value='cc'>primitive call count</option>
<option value='tt'>total time</option>
<option value='ct'>cumulative time</option>
</select>
</td>
<td>
<select name='plottype'>
<option value='bar'>bar</option>
<option value='pie'>pie</option>
</select>
<td>
<input type="submit" name="plot" value="plot"/>
</td>
<td>
<select name='format'>
<option value='default'>binary</option>
<option value='json'>json</option>
<option value='csv'>csv</option>
<option value='ods'>ODF.ods</option>
</select>
</td>
<td>
<input type="submit" name="download" value="download"/>
</td>
<td>
<input type="submit" name="clear" value="clear"/>
</td>
</tr>
</table>
</div>
"""
index_tmpl = """
<html>
<head>
<title>profile results</title>
<style>
<!--
tr.normal { background-color: #ffffff }
tr.hover { background-color: #88eeee }
//-->
</style>
</head>
<body>
<form action="${action}" method="POST">
<div class="form-text">
${description}
</div>
<hr />
${formelements}
</form>
<pre>
${profilehtml}
</pre>
</body>
</html>
"""
class HTMLViewer(object):
format_dict = {'default': 'application/octet-stream',
'json': 'application/json',
'csv': 'text/csv',
'ods': 'application/vnd.oasis.opendocument.spreadsheet',
'python': 'text/html'}
def __init__(self, app_path, profile_module, profile_log):
self.app_path = app_path
self.profile_module = profile_module
self.profile_log = profile_log
def _get_param(self, query_dict, key, default=None, multiple=False):
value = query_dict.get(key, default)
if value is None or value == '':
return default
if multiple:
return value
if isinstance(value, list):
return eval(value[0]) if isinstance(default, int) else value[0]
else:
return value
def render(self, url, method, path_entry, query_dict, clear_callback):
plot = self._get_param(query_dict, 'plot', None)
download = self._get_param(query_dict, 'download', None)
clear = self._get_param(query_dict, 'clear', None)
action = plot or download or clear
profile_id = self._get_param(query_dict, 'profile', 'current')
sort = self._get_param(query_dict, 'sort', 'time')
limit = self._get_param(query_dict, 'limit', -1)
fulldirs = self._get_param(query_dict, 'fulldirs', 0)
nfl_filter = self._get_param(query_dict, 'nfl_filter', '').strip()
metric_selected = self._get_param(query_dict, 'metric', 'cc')
plot_type = self._get_param(query_dict, 'plottype', 'bar')
download_format = self._get_param(query_dict, 'format', 'default')
content = ''
# GET /__profile, POST /__profile
if len(path_entry) == 2 and method in ['GET', 'POST']:
log_files = self.profile_log.get_logfiles(profile_id)
if action == 'plot':
content, headers = self.plot(log_files, sort, limit,
nfl_filter, metric_selected,
plot_type)
elif action == 'download':
content, headers = self.download(log_files, sort, limit,
nfl_filter, download_format)
else:
if action == 'clear':
self.profile_log.clear(profile_id)
clear_callback and clear_callback()
content, headers = self.index_page(log_files, sort, limit,
fulldirs, nfl_filter,
profile_id, url)
# GET /__profile__/all
# GET /__profile__/current
# GET /__profile__/profile_id
# GET /__profile__/profile_id/
# GET /__profile__/profile_id/account.py:50(GETorHEAD)
# GET /__profile__/profile_id/swift/proxy/controllers
# /account.py:50(GETorHEAD)
# with QUERY_STRING: ?format=[default|json|csv|ods]
elif len(path_entry) > 2 and method == 'GET':
profile_id = path_entry[2]
log_files = self.profile_log.get_logfiles(profile_id)
pids = self.profile_log.get_all_pids()
# return all profiles in a json format by default.
# GET /__profile__/
if profile_id == '':
content = '{"profile_ids": ["' + '","'.join(pids) + '"]}'
headers = [('content-type', self.format_dict['json'])]
else:
if len(path_entry) > 3 and path_entry[3] != '':
nfl_filter = '/'.join(path_entry[3:])
if path_entry[-1].find(':0') == -1:
nfl_filter = '/' + nfl_filter
content, headers = self.download(log_files, sort, -1,
nfl_filter, download_format)
headers.append(('Access-Control-Allow-Origin', '*'))
else:
raise MethodNotAllowed(_('method %s is not allowed.') % method)
return content, headers
def index_page(self, log_files=None, sort='time', limit=-1,
fulldirs=0, nfl_filter='', profile_id='current', url='#'):
headers = [('content-type', 'text/html')]
if len(log_files) == 0:
return empty_description, headers
try:
stats = Stats2(*log_files)
except (IOError, ValueError):
raise DataLoadFailure(_('Can not load profile data from %s.')
% log_files)
if not fulldirs:
stats.strip_dirs()
stats.sort_stats(sort)
nfl_filter_esc =\
nfl_filter.replace('(', '\(').replace(')', '\)')
amount = [nfl_filter_esc, limit] if nfl_filter_esc else [limit]
profile_html = self.generate_stats_html(stats, self.app_path,
profile_id, *amount)
description = "Profiling information is generated by using\
'%s' profiler." % self.profile_module
sort_repl = '<option value="%s">' % sort
sort_selected = '<option value="%s" selected>' % sort
sort = sort_tmpl.replace(sort_repl, sort_selected)
plist = ''.join(['<option value="%s">%s</option>' % (p, p)
for p in self.profile_log.get_all_pids()])
profile_element = string.Template(profile_tmpl).substitute(
{'profile_list': plist})
profile_repl = '<option value="%s">' % profile_id
profile_selected = '<option value="%s" selected>' % profile_id
profile_element = profile_element.replace(profile_repl,
profile_selected)
limit_repl = '<option value="%s">' % limit
limit_selected = '<option value="%s" selected>' % limit
limit = limit_tmpl.replace(limit_repl, limit_selected)
fulldirs_checked = 'checked' if fulldirs else ''
fulldirs_element = string.Template(fulldirs_tmpl).substitute(
{'fulldir_checked': fulldirs_checked})
nfl_filter_element = string.Template(nfl_filter_tmpl).\
substitute({'nfl_filter': nfl_filter})
form_elements = string.Template(formelements_tmpl).substitute(
{'description': description,
'action': url,
'profile': profile_element,
'sort': sort,
'limit': limit,
'fulldirs': fulldirs_element,
'nfl_filter': nfl_filter_element,
}
)
content = string.Template(index_tmpl).substitute(
{'formelements': form_elements,
'action': url,
'description': description,
'profilehtml': profile_html,
})
return content, headers
def download(self, log_files, sort='time', limit=-1, nfl_filter='',
output_format='default'):
if len(log_files) == 0:
raise NotFoundException(_('no log file found'))
try:
nfl_esc = nfl_filter.replace('(', '\(').replace(')', '\)')
# remove the slash that is intentionally added in the URL
# to avoid failure of filtering stats data.
if nfl_esc.startswith('/'):
nfl_esc = nfl_esc[1:]
stats = Stats2(*log_files)
stats.sort_stats(sort)
if output_format == 'python':
data = self.format_source_code(nfl_filter)
elif output_format == 'json':
data = stats.to_json(nfl_esc, limit)
elif output_format == 'csv':
data = stats.to_csv(nfl_esc, limit)
elif output_format == 'ods':
data = stats.to_ods(nfl_esc, limit)
else:
data = stats.print_stats()
return data, [('content-type', self.format_dict[output_format])]
except ODFLIBNotInstalled as ex:
raise ex
except Exception as ex:
raise ProfileException(_('Data download error: %s') % ex)
def plot(self, log_files, sort='time', limit=10, nfl_filter='',
metric_selected='cc', plot_type='bar'):
if not PLOTLIB_INSTALLED:
raise PLOTLIBNotInstalled(_('python-matplotlib not installed.'))
if len(log_files) == 0:
raise NotFoundException(_('no log file found'))
try:
stats = Stats2(*log_files)
stats.sort_stats(sort)
stats_dict = stats.stats
__, func_list = stats.get_print_list([nfl_filter, limit])
nfls = []
performance = []
names = {'nc': 'Total Call Count', 'cc': 'Primitive Call Count',
'tt': 'Total Time', 'ct': 'Cumulative Time'}
for func in func_list:
cc, nc, tt, ct, __ = stats_dict[func]
metric = {'cc': cc, 'nc': nc, 'tt': tt, 'ct': ct}
nfls.append(func[2])
performance.append(metric[metric_selected])
y_pos = range(len(nfls))
error = [random.random() for __ in y_pos]
plt.clf()
if plot_type == 'pie':
plt.pie(x=performance, explode=None, labels=nfls,
autopct='%1.1f%%')
else:
plt.barh(y_pos, performance, xerr=error, align='center',
alpha=0.4)
plt.yticks(y_pos, nfls)
plt.xlabel(names[metric_selected])
plt.title('Profile Statistics (by %s)' % names[metric_selected])
#plt.gcf().tight_layout(pad=1.2)
with tempfile.TemporaryFile() as profile_img:
plt.savefig(profile_img, format='png', dpi=300)
profile_img.seek(0)
data = profile_img.read()
return data, [('content-type', 'image/jpg')]
except Exception as ex:
raise ProfileException(_('plotting results failed due to %s') % ex)
def format_source_code(self, nfl):
nfls = re.split('[:()]', nfl)
file_path = nfls[0]
try:
lineno = int(nfls[1])
except (TypeError, ValueError, IndexError):
lineno = 0
# for security reason, this need to be fixed.
if not file_path.endswith('.py'):
return _('The file type are forbidden to access!')
try:
data = []
i = 0
with open(file_path) as f:
lines = f.readlines()
max_width = str(len(str(len(lines))))
fmt = '<span id="L%d" rel="#L%d">%' + max_width\
+ 'd|<code>%s</code></span>'
for line in lines:
l = cgi.escape(line, quote=None)
i = i + 1
if i == lineno:
fmt2 = '<span id="L%d" style="background-color: \
rgb(127,255,127)">%' + max_width +\
'd|<code>%s</code></span>'
data.append(fmt2 % (i, i, l))
else:
data.append(fmt % (i, i, i, l))
data = ''.join(data)
except Exception:
return _('Can not access the file %s.') % file_path
return '<pre>%s</pre>' % data
def generate_stats_html(self, stats, app_path, profile_id, *selection):
html = []
for filename in stats.files:
html.append('<p>%s</p>' % filename)
try:
for func in stats.top_level:
html.append('<p>%s</p>' % func[2])
html.append('%s function calls' % stats.total_calls)
if stats.total_calls != stats.prim_calls:
html.append("(%d primitive calls)" % stats.prim_calls)
html.append('in %.3f seconds' % stats.total_tt)
if stats.fcn_list:
stat_list = stats.fcn_list[:]
msg = "<p>Ordered by: %s</p>" % stats.sort_type
else:
stat_list = stats.stats.keys()
msg = '<p>Random listing order was used</p>'
for sel in selection:
stat_list, msg = stats.eval_print_amount(sel, stat_list, msg)
html.append(msg)
html.append('<table style="border-width: 1px">')
if stat_list:
html.append('<tr><th>#</th><th>Call Count</th>\
<th>Total Time</th><th>Time/Call</th>\
<th>Cumulative Time</th>\
<th>Cumulative Time/Call</th>\
<th>Filename:Lineno(Function)</th>\
<th>JSON</th>\
</tr>')
count = 0
for func in stat_list:
count = count + 1
html.append('<tr onMouseOver="this.className=\'hover\'"\
onMouseOut="this.className=\'normal\'">\
<td>%d)</td>' % count)
cc, nc, tt, ct, __ = stats.stats[func]
c = str(nc)
if nc != cc:
c = c + '/' + str(cc)
html.append('<td>%s</td>' % c)
html.append('<td>%f</td>' % tt)
if nc == 0:
html.append('<td>-</td>')
else:
html.append('<td>%f</td>' % (float(tt) / nc))
html.append('<td>%f</td>' % ct)
if cc == 0:
html.append('<td>-</td>')
else:
html.append('<td>%f</td>' % (float(ct) / cc))
nfls = cgi.escape(stats.func_std_string(func))
if nfls.split(':')[0] not in ['', 'profile'] and\
os.path.isfile(nfls.split(':')[0]):
html.append('<td><a href="%s/%s%s?format=python#L%d">\
%s</a></td>' % (app_path, profile_id,
nfls, func[1], nfls))
else:
html.append('<td>%s</td>' % nfls)
if not nfls.startswith('/'):
nfls = '/' + nfls
html.append('<td><a href="%s/%s%s?format=json">\
--></a></td></tr>' % (app_path,
profile_id, nfls))
except Exception as ex:
html.append("Exception:" % ex.message)
return ''.join(html)
| apache-2.0 |
williamdjones/protein_binding | convert_csv_to_h5.py | 1 | 3637 | '''
The purpose of this script is to take a csv file containing protein_binding data and create an h5 with a specified proportion
of examples to hold as a testing set.
by: Derek Jones
'''
import time
import os
import h5py
import pandas as pd
import numpy as np
import argparse
import numpy as np
from tqdm import tqdm
random_state = np.random.RandomState(0)
from sklearn.model_selection import train_test_split
parser = argparse.ArgumentParser()
parser.add_argument("-i", type=str, help="path to old csv file")
parser.add_argument("-o", type=str, help="path to new h5 file")
parser.add_argument("-c", type=str, help="prefix for compound lists")
parser.add_argument("--a", type=float, help="ratio of examples to hold out for test set", default=0.2) #create 80/20 split
args = parser.parse_args()
def save_to_hdf5(data_frame, output_name):
output_file = h5py.File(output_name, "w", libver='latest')
column_names = list(data_frame.columns.values)
group_names = list(set(data_frame['receptor']))
output_file.create_group("train")
output_file.create_group("test")
for group_name in tqdm(group_names):
grp_data = data_frame[data_frame['receptor'] == group_name]
labels = data_frame[data_frame['receptor'] == group_name]["label"]
idxs = np.arange(0, len(labels))
train_idxs, test_idxs = train_test_split(idxs, stratify=labels, test_size=args.a, random_state=random_state)
data_frame.iloc[train_idxs][["receptor","drugID","label","vina_score"]].to_csv(args.c+"_training_compounds.csv")
data_frame.iloc[test_idxs][["receptor", "drugID", "label", "vina_score"]].to_csv(args.c + "_testing_compounds.csv")
output_file['/train'].create_group(group_name)
output_file['/test'].create_group(group_name)
for feature in iter(column_names):
# print(feature)
if feature == "label":
output_file['train/'+str(group_name)].require_dataset(str(feature), [grp_data.iloc[train_idxs].shape[0], 1],
data=np.asarray(grp_data.iloc[train_idxs][feature]),
dtype=np.int8)
output_file['test/'+str(group_name)].require_dataset(str(feature), [grp_data.iloc[test_idxs].shape[0], 1], data=np.asarray(grp_data.iloc[test_idxs][feature]),
dtype=np.int8)
elif feature in ['receptor','drugID','Filename']:
output_file['train/'+str(group_name)].require_dataset(str(feature), [grp_data.iloc[train_idxs].shape[0], 1],
data=np.asarray(grp_data.iloc[train_idxs][feature]),
dtype=h5py.special_dtype(vlen=str))
output_file['test/'+str(group_name)].require_dataset(str(feature), [grp_data.iloc[test_idxs].shape[0], 1],
data=np.asarray(grp_data.iloc[test_idxs][feature]),
dtype=h5py.special_dtype(vlen=str))
else:
output_file['train/'+str(group_name)+"/"+str(feature)] = np.asarray(pd.to_numeric(grp_data.iloc[train_idxs][feature]),dtype=np.float16)
output_file['test/'+str(group_name)+"/"+str(feature)] = np.asarray(pd.to_numeric(grp_data.iloc[test_idxs][feature]),dtype=np.float16)
output_file.close()
t0 = time.clock()
save_to_hdf5(pd.read_csv(args.i, keep_default_na=False,na_values=[np.nan, 'na']).convert_objects(convert_numeric=True), args.o)
t1 = time.clock()
print(args.i, "converted to .h5 in", (t1-t0), "seconds.")
| mit |
clemkoa/scikit-learn | examples/neighbors/plot_kde_1d.py | 60 | 5120 | """
===================================
Simple 1D Kernel Density Estimation
===================================
This example uses the :class:`sklearn.neighbors.KernelDensity` class to
demonstrate the principles of Kernel Density Estimation in one dimension.
The first plot shows one of the problems with using histograms to visualize
the density of points in 1D. Intuitively, a histogram can be thought of as a
scheme in which a unit "block" is stacked above each point on a regular grid.
As the top two panels show, however, the choice of gridding for these blocks
can lead to wildly divergent ideas about the underlying shape of the density
distribution. If we instead center each block on the point it represents, we
get the estimate shown in the bottom left panel. This is a kernel density
estimation with a "top hat" kernel. This idea can be generalized to other
kernel shapes: the bottom-right panel of the first figure shows a Gaussian
kernel density estimate over the same distribution.
Scikit-learn implements efficient kernel density estimation using either
a Ball Tree or KD Tree structure, through the
:class:`sklearn.neighbors.KernelDensity` estimator. The available kernels
are shown in the second figure of this example.
The third figure compares kernel density estimates for a distribution of 100
samples in 1 dimension. Though this example uses 1D distributions, kernel
density estimation is easily and efficiently extensible to higher dimensions
as well.
"""
# Author: Jake Vanderplas <[email protected]>
#
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from sklearn.neighbors import KernelDensity
#----------------------------------------------------------------------
# Plot the progression of histograms to kernels
np.random.seed(1)
N = 20
X = np.concatenate((np.random.normal(0, 1, int(0.3 * N)),
np.random.normal(5, 1, int(0.7 * N))))[:, np.newaxis]
X_plot = np.linspace(-5, 10, 1000)[:, np.newaxis]
bins = np.linspace(-5, 10, 10)
fig, ax = plt.subplots(2, 2, sharex=True, sharey=True)
fig.subplots_adjust(hspace=0.05, wspace=0.05)
# histogram 1
ax[0, 0].hist(X[:, 0], bins=bins, fc='#AAAAFF', normed=True)
ax[0, 0].text(-3.5, 0.31, "Histogram")
# histogram 2
ax[0, 1].hist(X[:, 0], bins=bins + 0.75, fc='#AAAAFF', normed=True)
ax[0, 1].text(-3.5, 0.31, "Histogram, bins shifted")
# tophat KDE
kde = KernelDensity(kernel='tophat', bandwidth=0.75).fit(X)
log_dens = kde.score_samples(X_plot)
ax[1, 0].fill(X_plot[:, 0], np.exp(log_dens), fc='#AAAAFF')
ax[1, 0].text(-3.5, 0.31, "Tophat Kernel Density")
# Gaussian KDE
kde = KernelDensity(kernel='gaussian', bandwidth=0.75).fit(X)
log_dens = kde.score_samples(X_plot)
ax[1, 1].fill(X_plot[:, 0], np.exp(log_dens), fc='#AAAAFF')
ax[1, 1].text(-3.5, 0.31, "Gaussian Kernel Density")
for axi in ax.ravel():
axi.plot(X[:, 0], np.zeros(X.shape[0]) - 0.01, '+k')
axi.set_xlim(-4, 9)
axi.set_ylim(-0.02, 0.34)
for axi in ax[:, 0]:
axi.set_ylabel('Normalized Density')
for axi in ax[1, :]:
axi.set_xlabel('x')
#----------------------------------------------------------------------
# Plot all available kernels
X_plot = np.linspace(-6, 6, 1000)[:, None]
X_src = np.zeros((1, 1))
fig, ax = plt.subplots(2, 3, sharex=True, sharey=True)
fig.subplots_adjust(left=0.05, right=0.95, hspace=0.05, wspace=0.05)
def format_func(x, loc):
if x == 0:
return '0'
elif x == 1:
return 'h'
elif x == -1:
return '-h'
else:
return '%ih' % x
for i, kernel in enumerate(['gaussian', 'tophat', 'epanechnikov',
'exponential', 'linear', 'cosine']):
axi = ax.ravel()[i]
log_dens = KernelDensity(kernel=kernel).fit(X_src).score_samples(X_plot)
axi.fill(X_plot[:, 0], np.exp(log_dens), '-k', fc='#AAAAFF')
axi.text(-2.6, 0.95, kernel)
axi.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
axi.xaxis.set_major_locator(plt.MultipleLocator(1))
axi.yaxis.set_major_locator(plt.NullLocator())
axi.set_ylim(0, 1.05)
axi.set_xlim(-2.9, 2.9)
ax[0, 1].set_title('Available Kernels')
#----------------------------------------------------------------------
# Plot a 1D density example
N = 100
np.random.seed(1)
X = np.concatenate((np.random.normal(0, 1, int(0.3 * N)),
np.random.normal(5, 1, int(0.7 * N))))[:, np.newaxis]
X_plot = np.linspace(-5, 10, 1000)[:, np.newaxis]
true_dens = (0.3 * norm(0, 1).pdf(X_plot[:, 0])
+ 0.7 * norm(5, 1).pdf(X_plot[:, 0]))
fig, ax = plt.subplots()
ax.fill(X_plot[:, 0], true_dens, fc='black', alpha=0.2,
label='input distribution')
for kernel in ['gaussian', 'tophat', 'epanechnikov']:
kde = KernelDensity(kernel=kernel, bandwidth=0.5).fit(X)
log_dens = kde.score_samples(X_plot)
ax.plot(X_plot[:, 0], np.exp(log_dens), '-',
label="kernel = '{0}'".format(kernel))
ax.text(6, 0.38, "N={0} points".format(N))
ax.legend(loc='upper left')
ax.plot(X[:, 0], -0.005 - 0.01 * np.random.random(X.shape[0]), '+k')
ax.set_xlim(-4, 9)
ax.set_ylim(-0.02, 0.4)
plt.show()
| bsd-3-clause |
metpy/MetPy | metpy/testing.py | 1 | 6677 | # Copyright (c) 2015,2016,2018 MetPy Developers.
# Distributed under the terms of the BSD 3-Clause License.
# SPDX-License-Identifier: BSD-3-Clause
r"""Collection of utilities for testing.
This includes:
* unit-aware test functions
* code for testing matplotlib figures
"""
from __future__ import absolute_import
import functools
import numpy as np
import numpy.testing
from pint import DimensionalityError
import pytest
import xarray as xr
from metpy.calc import wind_components
from metpy.cbook import get_test_data
from metpy.deprecation import MetpyDeprecationWarning
from .units import units
def get_upper_air_data(date, station):
"""Get upper air observations from the test data cache.
Parameters
----------
time : datetime
The date and time of the desired observation.
station : str
The three letter ICAO identifier of the station for which data should be
downloaded.
Returns
-------
dict : upper air data
"""
sounding_key = '{0:%Y-%m-%dT%HZ}_{1:}'.format(date, station)
sounding_files = {'2016-05-22T00Z_DDC': 'may22_sounding.txt',
'2013-01-20T12Z_OUN': 'jan20_sounding.txt',
'1999-05-04T00Z_OUN': 'may4_sounding.txt',
'2002-11-11T00Z_BNA': 'nov11_sounding.txt',
'2010-12-09T12Z_BOI': 'dec9_sounding.txt'}
fname = sounding_files[sounding_key]
fobj = get_test_data(fname)
def to_float(s):
# Remove all whitespace and replace empty values with NaN
if not s.strip():
s = 'nan'
return float(s)
# Skip dashes, column names, units, and more dashes
for _ in range(4):
fobj.readline()
# Initiate lists for variables
arr_data = []
# Read all lines of data and append to lists only if there is some data
for row in fobj:
level = to_float(row[0:7])
values = (to_float(row[7:14]), to_float(row[14:21]), to_float(row[21:28]),
to_float(row[42:49]), to_float(row[49:56]))
if any(np.invert(np.isnan(values[1:]))):
arr_data.append((level,) + values)
p, z, t, td, direc, spd = np.array(arr_data).T
p = p * units.hPa
z = z * units.meters
t = t * units.degC
td = td * units.degC
direc = direc * units.degrees
spd = spd * units.knots
u, v = wind_components(spd, direc)
return {'pressure': p, 'height': z, 'temperature': t,
'dewpoint': td, 'direction': direc, 'speed': spd, 'u_wind': u, 'v_wind': v}
def check_and_drop_units(actual, desired):
r"""Check that the units on the passed in arrays are compatible; return the magnitudes.
Parameters
----------
actual : `pint.Quantity` or array-like
desired : `pint.Quantity` or array-like
Returns
-------
actual, desired
array-like versions of `actual` and `desired` once they have been
coerced to compatible units.
Raises
------
AssertionError
If the units on the passed in objects are not compatible.
"""
try:
# If the desired result has units, add dimensionless units if necessary, then
# ensure that this is compatible to the desired result.
if hasattr(desired, 'units'):
if not hasattr(actual, 'units'):
actual = units.Quantity(actual, 'dimensionless')
actual = actual.to(desired.units)
# Otherwise, the desired result has no units. Convert the actual result to
# dimensionless units if it is a united quantity.
else:
if hasattr(actual, 'units'):
actual = actual.to('dimensionless')
except DimensionalityError:
raise AssertionError('Units are not compatible: {} should be {}'.format(
actual.units, getattr(desired, 'units', 'dimensionless')))
except AttributeError:
pass
if hasattr(actual, 'magnitude'):
actual = actual.magnitude
if hasattr(desired, 'magnitude'):
desired = desired.magnitude
return actual, desired
def assert_nan(value, units):
"""Check for nan with proper units."""
value, _ = check_and_drop_units(value, np.nan * units)
assert np.isnan(value)
def assert_almost_equal(actual, desired, decimal=7):
"""Check that values are almost equal, including units.
Wrapper around :func:`numpy.testing.assert_almost_equal`
"""
actual, desired = check_and_drop_units(actual, desired)
numpy.testing.assert_almost_equal(actual, desired, decimal)
def assert_array_almost_equal(actual, desired, decimal=7):
"""Check that arrays are almost equal, including units.
Wrapper around :func:`numpy.testing.assert_array_almost_equal`
"""
actual, desired = check_and_drop_units(actual, desired)
numpy.testing.assert_array_almost_equal(actual, desired, decimal)
def assert_array_equal(actual, desired):
"""Check that arrays are equal, including units.
Wrapper around :func:`numpy.testing.assert_array_equal`
"""
actual, desired = check_and_drop_units(actual, desired)
numpy.testing.assert_array_equal(actual, desired)
def assert_xarray_allclose(actual, desired):
"""Check that the xarrays are almost equal, including coordinates and attributes."""
xr.testing.assert_allclose(actual, desired)
assert desired.metpy.coordinates_identical(actual)
assert desired.attrs == actual.attrs
@pytest.fixture(scope='module', autouse=True)
def set_agg_backend():
"""Fixture to ensure the Agg backend is active."""
import matplotlib.pyplot as plt
prev_backend = plt.get_backend()
try:
plt.switch_backend('agg')
yield
finally:
plt.switch_backend(prev_backend)
@pytest.fixture(autouse=True)
def patch_round(monkeypatch):
"""Fixture to patch builtin round using numpy's.
This works around the fact that built-in round changed between Python 2 and 3. This
is probably not needed once we're testing on matplotlib 2.0, which has been updated
to use numpy's throughout.
"""
monkeypatch.setitem(__builtins__, 'round', np.round)
def check_and_silence_deprecation(func):
"""Decorate a function to swallow metpy deprecation warnings, making sure they are present.
This should be used on deprecated function tests to make sure the deprecation warnings
are not printing in the tests, but checks that the warning is present and makes sure
the function still works as intended.
"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
with pytest.warns(MetpyDeprecationWarning):
return func(*args, **kwargs)
return wrapper
| bsd-3-clause |
jpinedaf/pyspeckit | pyspeckit/spectrum/models/formaldehyde.py | 3 | 23644 | """
===========================
Formaldehyde cm-line fitter
===========================
This is a formaldehyde 1_11-1_10 / 2_12-2_11 fitter. It includes hyperfine
components of the formaldehyde lines and has both LTE and RADEX LVG based
models
Module API
^^^^^^^^^^
"""
from __future__ import print_function
import numpy as np
from ...mpfit import mpfit
from .. import units
from . import fitter,model,modelgrid
import matplotlib.cbook as mpcb
import copy
from . import hyperfine
from ...specwarnings import warn
from six.moves import xrange
try: # for model grid reading
import astropy.io.fits as pyfits
except ImportError:
import pyfits
try:
import scipy.interpolate
import scipy.ndimage
scipyOK = True
except ImportError:
scipyOK=False
line_names = ['oneone','twotwo','threethree']
line_names = ['oneone_f10', 'oneone_f01', 'oneone_f22', 'oneone_f21',
'oneone_f12', 'oneone_f11', 'twotwo_f11', 'twotwo_f12',
'twotwo_f21', 'twotwo_f32', 'twotwo_f33', 'twotwo_f22',
'twotwo_f23']
# http://adsabs.harvard.edu/abs/1971ApJ...169..429T has the most accurate freqs
# http://adsabs.harvard.edu/abs/1972ApJ...174..463T [twotwo]
central_freq_dict = {
'oneone': 4.82965996e9,
'twotwo': 14.48847881e9,
'threethree': 28.97480e9,
}
line_strength_dict={
'oneone_f10': 4.,
'oneone_f01': 4.,
'oneone_f22': 15.,
'oneone_f21': 5.,
'oneone_f12': 5.,
'oneone_f11': 3.,
'twotwo_f11': 15.,
'twotwo_f12': 5.,
'twotwo_f21': 5.,
'twotwo_f32': 5.19,
'twotwo_f33': 41.48,
'twotwo_f22': 23.15,
'twotwo_f23': 5.19,
'threethree_f22':1,
'threethree_f44':1,
'threethree_f33':1,
}
relative_strength_total_degeneracy={
'oneone_f10': 36.,
'oneone_f01': 36.,
'oneone_f22': 36.,
'oneone_f21': 36.,
'oneone_f12': 36.,
'oneone_f11': 36.,
'twotwo_f11': 100.01,
'twotwo_f12': 100.01,
'twotwo_f21': 100.01,
'twotwo_f32': 100.01,
'twotwo_f33': 100.01,
'twotwo_f22': 100.01,
'twotwo_f23': 100.01,
'threethree_f22':3.0,
'threethree_f44':3.0,
'threethree_f33':3.0,
}
hf_freq_dict={
'oneone_f10':4.82965996e9 - 18.53e3,
'oneone_f01':4.82965996e9 - 1.34e3,
'oneone_f22':4.82965996e9 - 0.35e3,
'oneone_f21':4.82965996e9 + 4.05e3,
'oneone_f12':4.82965996e9 + 6.48e3,
'oneone_f11':4.82965996e9 + 11.08e3,
'twotwo_f11':14.48847881e9 - 19.97e3,
'twotwo_f12':14.48847881e9 - 7.03e3,
'twotwo_f21':14.48847881e9 - 2.20e3,
'twotwo_f32':14.48847881e9 + 0.12e3,
'twotwo_f33':14.48847881e9 + 0.89e3,
'twotwo_f22':14.48847881e9 + 10.74e3,
'twotwo_f23':14.48847881e9 + 11.51e3,
'threethree_f22':28.97478e9,
'threethree_f44':28.97480e9,
'threethree_f33':28.97481e9,
}
freq_dict = copy.copy(hf_freq_dict)
freq_dict.update(central_freq_dict)
aval_dict = {
'oneone': 10**-8.44801, #64*!pi**4/(3*h*c**3)*nu11**3*mu0**2*(1/2.)
'twotwo': 10**-7.49373, #64*!pi**4/(3*h*c**3)*nu22**3*mu0**2*(2/3.)
'threethree': 10**-6.89179, #64*!pi**4/(3*h*c**3)*nu33**3*mu0**2*(3/4.)
}
hf_aval_dict={
'oneone_f10':10**-8.92509,
'oneone_f01':10**-8.44797,
'oneone_f22':10**-8.57294,
'oneone_f21':10**-9.05004,
'oneone_f12':10**-8.82819,
'oneone_f11':10**-9.05009,
'twotwo_f11':10**-7.61876,
'twotwo_f12':10**-8.09586,
'twotwo_f21':10**-8.31771,
'twotwo_f32':10**-8.44804,
'twotwo_f33':10**-7.54494,
'twotwo_f22':10**-7.65221,
'twotwo_f23':10**-8.30191,
'threethree_f22':10**-6.94294,
'threethree_f44':10**-6.91981,
'threethree_f33':10**-6.96736,
}
ortho_dict = {
'oneone': False,
'twotwo': False,
'threethree': False,
}
n_ortho = np.arange(0,28,3) # 0..3..27
n_para = np.array([x for x in range(28) if x % 3 != 0])
voff_lines_dict = {
'oneone': [(hf_freq_dict[f]-freq_dict['oneone'])/freq_dict['oneone']*units.speedoflight_ms for f in hf_freq_dict.keys() if "oneone" in f],
'twotwo': [(hf_freq_dict[f]-freq_dict['twotwo'])/freq_dict['twotwo']*units.speedoflight_ms for f in hf_freq_dict.keys() if "twotwo" in f],
'threethree': [(hf_freq_dict[f]-freq_dict['threethree'])/freq_dict['threethree']*units.speedoflight_ms for f in hf_freq_dict.keys() if "threethree" in f],
}
voff_lines_dict={ # opposite signs of freq offset
'oneone_f10': + 18.53e3/freq_dict['oneone'] * units.speedoflight_ms / 1000.0,
'oneone_f01': + 1.34e3 /freq_dict['oneone'] * units.speedoflight_ms / 1000.0,
'oneone_f22': + 0.35e3 /freq_dict['oneone'] * units.speedoflight_ms / 1000.0,
'oneone_f21': - 4.05e3 /freq_dict['oneone'] * units.speedoflight_ms / 1000.0,
'oneone_f12': - 6.48e3 /freq_dict['oneone'] * units.speedoflight_ms / 1000.0,
'oneone_f11': - 11.08e3/freq_dict['oneone'] * units.speedoflight_ms / 1000.0,
'twotwo_f11': + 19.97e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'twotwo_f12': + 7.03e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'twotwo_f21': + 2.20e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'twotwo_f32': - 0.12e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'twotwo_f33': - 0.89e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'twotwo_f22': - 10.74e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'twotwo_f23': - 11.51e3/freq_dict['twotwo'] * units.speedoflight_ms / 1000.0,
'threethree_f22':28.97478e9,
'threethree_f44':28.97480e9,
'threethree_f33':28.97481e9,
}
formaldehyde_vtau = hyperfine.hyperfinemodel(line_names, voff_lines_dict,
freq_dict, line_strength_dict,
relative_strength_total_degeneracy)
formaldehyde_vtau_fitter = formaldehyde_vtau.fitter
formaldehyde_vtau_vheight_fitter = formaldehyde_vtau.vheight_fitter
formaldehyde_vtau_tbg_fitter = formaldehyde_vtau.background_fitter
def formaldehyde_radex(xarr, density=4, column=13, xoff_v=0.0, width=1.0,
grid_vwidth=1.0, grid_vwidth_scale=False, texgrid=None,
taugrid=None, hdr=None, path_to_texgrid='',
path_to_taugrid='', temperature_gridnumber=3,
debug=False, verbose=False, **kwargs):
"""
Use a grid of RADEX-computed models to make a model line spectrum
The RADEX models have to be available somewhere.
OR they can be passed as arrays. If as arrays, the form should be:
texgrid = ((minfreq1,maxfreq1,texgrid1),(minfreq2,maxfreq2,texgrid2))
xarr must be a SpectroscopicAxis instance
xoff_v, width are both in km/s
grid_vwidth is the velocity assumed when computing the grid in km/s
this is important because tau = modeltau / width (see, e.g.,
Draine 2011 textbook pgs 219-230)
grid_vwidth_scale is True or False: False for LVG, True for Sphere
"""
if texgrid is None and taugrid is None:
if path_to_texgrid == '' or path_to_taugrid=='':
raise IOError("Must specify model grids to use.")
else:
taugrid = [pyfits.getdata(path_to_taugrid)]
texgrid = [pyfits.getdata(path_to_texgrid)]
hdr = pyfits.getheader(path_to_taugrid)
yinds,xinds = np.indices(taugrid[0].shape[1:])
densityarr = (xinds+hdr['CRPIX1']-1)*hdr['CD1_1']+hdr['CRVAL1'] # log density
columnarr = (yinds+hdr['CRPIX2']-1)*hdr['CD2_2']+hdr['CRVAL2'] # log column
minfreq = (4.8,)
maxfreq = (5.0,)
elif len(taugrid)==len(texgrid) and hdr is not None:
minfreq,maxfreq,texgrid = zip(*texgrid)
minfreq,maxfreq,taugrid = zip(*taugrid)
yinds,xinds = np.indices(taugrid[0].shape[1:])
densityarr = (xinds+hdr['CRPIX1']-1)*hdr['CD1_1']+hdr['CRVAL1'] # log density
columnarr = (yinds+hdr['CRPIX2']-1)*hdr['CD2_2']+hdr['CRVAL2'] # log column
else:
raise Exception
# Convert X-units to frequency in GHz
xarr = xarr.as_unit('Hz', quiet=True)
tau_nu_cumul = np.zeros(len(xarr))
gridval1 = np.interp(density, densityarr[0,:], xinds[0,:])
gridval2 = np.interp(column, columnarr[:,0], yinds[:,0])
if np.isnan(gridval1) or np.isnan(gridval2):
raise ValueError("Invalid column/density")
if scipyOK:
slices = [temperature_gridnumber] + [slice(int(np.floor(gv)),int(np.floor(gv))+2) for gv in (gridval2,gridval1)]
tau = [scipy.ndimage.map_coordinates(tg[slices],np.array([[gridval2%1],[gridval1%1]]),order=1) for tg in taugrid]
tex = [scipy.ndimage.map_coordinates(tg[slices],np.array([[gridval2%1],[gridval1%1]]),order=1) for tg in texgrid]
else:
raise ImportError("Couldn't import scipy, therefore cannot interpolate")
#tau = modelgrid.line_params_2D(gridval1,gridval2,densityarr,columnarr,taugrid[temperature_gridnumber,:,:])
#tex = modelgrid.line_params_2D(gridval1,gridval2,densityarr,columnarr,texgrid[temperature_gridnumber,:,:])
if verbose:
print("density %20.12g column %20.12g: tau %20.12g tex %20.12g" % (density, column, tau, tex))
if debug:
import pdb; pdb.set_trace()
spec = np.sum([(formaldehyde_vtau(xarr,Tex=float(tex[ii]),tau=float(tau[ii]),xoff_v=xoff_v,width=width, **kwargs)
* (xarr.as_unit('GHz')>minfreq[ii]) * (xarr.as_unit('GHz')<maxfreq[ii])) for ii in xrange(len(tex))],
axis=0)
return spec
def formaldehyde_radex_orthopara_temp(xarr, density=4, column=13,
orthopara=1.0, temperature=15.0,
xoff_v=0.0, width=1.0,
Tbackground1=2.73,
Tbackground2=2.73,
grid_vwidth=1.0,
grid_vwidth_scale=False, texgrid=None,
taugrid=None, hdr=None,
path_to_texgrid='', path_to_taugrid='',
debug=False, verbose=False,
getpars=False, **kwargs):
"""
Use a grid of RADEX-computed models to make a model line spectrum
The RADEX models have to be available somewhere.
OR they can be passed as arrays. If as arrays, the form should be:
texgrid = ((minfreq1,maxfreq1,texgrid1),(minfreq2,maxfreq2,texgrid2))
xarr must be a SpectroscopicAxis instance
xoff_v, width are both in km/s
grid_vwidth is the velocity assumed when computing the grid in km/s
this is important because tau = modeltau / width (see, e.g.,
Draine 2011 textbook pgs 219-230)
grid_vwidth_scale is True or False: False for LVG, True for Sphere
"""
if texgrid is None and taugrid is None:
if path_to_texgrid == '' or path_to_taugrid=='':
raise IOError("Must specify model grids to use.")
else:
taugrid = [pyfits.getdata(path_to_taugrid)]
texgrid = [pyfits.getdata(path_to_texgrid)]
hdr = pyfits.getheader(path_to_taugrid)
minfreq = (4.8,)
maxfreq = (5.0,)
elif len(taugrid)==len(texgrid) and hdr is not None:
minfreq,maxfreq,texgrid = zip(*texgrid)
minfreq,maxfreq,taugrid = zip(*taugrid)
else:
raise Exception
densityarr = (np.arange(taugrid[0].shape[3])+hdr['CRPIX1']-1)*hdr['CD1_1']+hdr['CRVAL1'] # log density
columnarr = (np.arange(taugrid[0].shape[2])+hdr['CRPIX2']-1)*hdr['CD2_2']+hdr['CRVAL2'] # log column
temparr = (np.arange(taugrid[0].shape[1])+hdr['CRPIX3']-1)*hdr['CDELT3']+hdr['CRVAL3'] # temperature
oprarr = (np.arange(taugrid[0].shape[0])+hdr['CRPIX4']-1)*hdr['CDELT4']+hdr['CRVAL4'] # log ortho/para ratio
gridval1 = np.interp(density, densityarr, np.arange(len(densityarr)))
gridval2 = np.interp(column, columnarr, np.arange(len(columnarr)))
gridval3 = np.interp(temperature, temparr, np.arange(len(temparr)))
gridval4 = np.interp(orthopara, oprarr, np.arange(len(oprarr)))
if np.isnan(gridval1) or np.isnan(gridval2):
raise ValueError("Invalid column/density")
if scipyOK:
slices = [slice(int(np.floor(gv)),int(np.floor(gv)+2))
for gv in (gridval4,gridval3,gridval2,gridval1)]
tau = [scipy.ndimage.map_coordinates(tg[slices],
np.array([[gridval4 % 1],
[gridval3 % 1],
[gridval2 % 1],
[gridval1 % 1]]),
order=1, prefilter=False)
for tg in taugrid]
tex = [scipy.ndimage.map_coordinates(tg[slices],
np.array([[gridval4 % 1],
[gridval3 % 1],
[gridval2 % 1],
[gridval1 % 1]]),
order=1,prefilter=False)
for tg in texgrid]
else:
raise ImportError("Couldn't import scipy, therefore cannot interpolate")
#tau = modelgrid.line_params_2D(gridval1,gridval2,densityarr,columnarr,taugrid[temperature_gridnumber,:,:])
#tex = modelgrid.line_params_2D(gridval1,gridval2,densityarr,columnarr,texgrid[temperature_gridnumber,:,:])
# there can be different background temperatures at each frequency
tbg = [Tbackground1,Tbackground2]
if verbose:
print("density %20.12g column: %20.12g temperature: %20.12g opr: %20.12g xoff_v: %20.12g width: %20.12g" % (density, column, temperature, orthopara, xoff_v, width))
print("tau: ",tau," tex: ",tex)
print("minfreq: ",minfreq," maxfreq: ",maxfreq)
print("tbg: ",tbg)
if debug > 1:
import pdb; pdb.set_trace()
if getpars:
return tau,tex
spec = np.sum([(formaldehyde_vtau(xarr.as_unit('Hz', quiet=True),
Tex=float(tex[ii]), tau=float(tau[ii]),
Tbackground=tbg[ii], xoff_v=xoff_v,
width=width, **kwargs)
* (xarr.as_unit('GHz')>minfreq[ii])
* (xarr.as_unit('GHz')<maxfreq[ii]))
for ii in xrange(len(tex))],
axis=0)
return spec
def formaldehyde(xarr, amp=1.0, xoff_v=0.0, width=1.0,
return_hyperfine_components=False, texscale=0.01, tau=0.01, **kwargs):
"""
Generate a model Formaldehyde spectrum based on simple gaussian parameters
the "amplitude" is an essentially arbitrary parameter; we therefore define
it to be Tex given tau=0.01 when passing to the fitter
The final spectrum is then rescaled to that value
"""
mdl = formaldehyde_vtau(xarr, Tex=amp*texscale, tau=tau, xoff_v=xoff_v,
width=width,
return_tau=True,
return_hyperfine_components=return_hyperfine_components, **kwargs)
if return_hyperfine_components:
mdlpeak = np.abs(mdl).squeeze().sum(axis=0).max()
else:
mdlpeak = np.abs(mdl).max()
if mdlpeak > 0:
mdl *= amp/mdlpeak
return mdl
def formaldehyde_pyradex(xarr, density=4, column=13, temperature=20,
xoff_v=0.0, opr=1.0, width=1.0, tbackground=2.73,
grid_vwidth=1.0, debug=False, verbose=False,
**kwargs):
"""
Use a grid of RADEX-computed models to make a model line spectrum
The RADEX models have to be available somewhere.
OR they can be passed as arrays. If as arrays, the form should be:
texgrid = ((minfreq1,maxfreq1,texgrid1),(minfreq2,maxfreq2,texgrid2))
xarr must be a SpectroscopicAxis instance
xoff_v, width are both in km/s
grid_vwidth is the velocity assumed when computing the grid in km/s
this is important because tau = modeltau / width (see, e.g.,
Draine 2011 textbook pgs 219-230)
"""
raise NotImplementedError("Not done yet.")
import pyradex
# Convert X-units to frequency in GHz
xarr = xarr.as_unit('Hz', quiet=True)
tb_nu_cumul = np.zeros(len(xarr))
R = pyradex.Radex(molecule='oh2co-h2', column=column,
temperature=temperature, density=10**density,
tbackground=tbackground,)
spec = np.sum([(formaldehyde_vtau(xarr,Tex=float(tex[ii]),tau=float(tau[ii]),xoff_v=xoff_v,width=width, **kwargs)
* (xarr.as_unit('GHz')>minfreq[ii]) * (xarr.as_unit('GHz')<maxfreq[ii])) for ii in xrange(len(tex))],
axis=0)
return spec
class formaldehyde_model(model.SpectralModel):
def formaldehyde_integral(self, modelpars, linename='oneone'):
"""
Return the integral of the individual components (ignoring height)
"""
raise NotImplementedError("Not implemented, but the integral is just amplitude * width * sqrt(2*pi)")
# produced by directly computing the integral of gaussians and formaldehydeians as a function of
# line width and then fitting that with a broken logarithmic power law
# The errors are <0.5% for all widths
formaldehyde_to_gaussian_ratio_coefs = {
'lt0.1_oneone': np.array([ -5.784020,-40.058798,-111.172706,-154.256411,-106.593122,-28.933119]),
'gt0.1_oneone': np.array([ 0.038548, -0.071162, -0.045710, 0.183828, -0.145429, 0.040039]),
'lt0.1_twotwo': np.array([ 1.156561, 6.638570, 11.782065, -0.429536,-24.860297,-27.902274, -9.510288]),
'gt0.1_twotwo': np.array([ -0.090646, 0.078204, 0.123181, -0.175590, 0.089506, -0.034687, 0.008676]),
}
integ = 0
if len(modelpars) % 3 == 0:
for amp,cen,width in np.reshape(modelpars,[len(modelpars)/3,3]):
gaussint = amp*width*np.sqrt(2.0*np.pi)
cftype = "gt0.1_"+linename if width > 0.1 else "lt0.1_"+linename
correction_factor = 10**np.polyval(formaldehyde_to_gaussian_ratio_coefs[cftype], np.log10(width) )
# debug statement print("Two components of the integral: amp %g, width %g, gaussint %g, correction_factor %g " % (amp,width,gaussint,correction_factor))
integ += gaussint*correction_factor
return integ
formaldehyde_fitter = formaldehyde_model(formaldehyde, 3,
parnames=['amp','center','width'],
parlimited=[(False,False),(False,False), (True,False)],
parlimits=[(0,0), (0,0), (0,0)],
shortvarnames=("A","v","\\sigma"), # specify the parameter names (TeX is OK)
fitunit='Hz' )
formaldehyde_vheight_fitter = formaldehyde_model(fitter.vheightmodel(formaldehyde), 4,
parnames=['height','amp','center','width'],
parlimited=[(False,False),(False,False),(False,False), (True,False)],
parlimits=[(0,0), (0,0), (0,0), (0,0)],
shortvarnames=("H","A","v","\\sigma"), # specify the parameter names (TeX is OK)
fitunit='Hz' )
# Create a tau-only fit:
def formaldehyde_radex_tau(xarr, density=4, column=13, xoff_v=0.0, width=1.0,
grid_vwidth=1.0, grid_vwidth_scale=False,
taugrid=None, hdr=None, path_to_taugrid='',
temperature_gridnumber=3, debug=False,
verbose=False, return_hyperfine_components=False,
**kwargs):
"""
Use a grid of RADEX-computed models to make a model line spectrum
* uses hyperfine components
* assumes *tau* varies but *tex* does not!
The RADEX models have to be available somewhere.
OR they can be passed as arrays. If as arrays, the form should be:
texgrid = ((minfreq1,maxfreq1,texgrid1),(minfreq2,maxfreq2,texgrid2))
xarr must be a SpectroscopicAxis instance
xoff_v, width are both in km/s
grid_vwidth is the velocity assumed when computing the grid in km/s
this is important because tau = modeltau / width (see, e.g.,
Draine 2011 textbook pgs 219-230)
grid_vwidth_scale is True or False: False for LVG, True for Sphere
"""
if verbose:
print("Parameters: dens=%f, column=%f, xoff=%f, width=%f" % (density, column, xoff_v, width))
if taugrid is None:
if path_to_taugrid=='':
raise IOError("Must specify model grids to use.")
else:
taugrid = [pyfits.getdata(path_to_taugrid)]
hdr = pyfits.getheader(path_to_taugrid)
yinds,xinds = np.indices(taugrid[0].shape[1:])
densityarr = (xinds+hdr['CRPIX1']-1)*hdr['CD1_1']+hdr['CRVAL1'] # log density
columnarr = (yinds+hdr['CRPIX2']-1)*hdr['CD2_2']+hdr['CRVAL2'] # log column
minfreq = (4.8,)
maxfreq = (5.0,)
elif hdr is not None:
minfreq,maxfreq,taugrid = zip(*taugrid)
yinds,xinds = np.indices(taugrid[0].shape[1:])
densityarr = (xinds+hdr['CRPIX1']-1)*hdr['CD1_1']+hdr['CRVAL1'] # log density
columnarr = (yinds+hdr['CRPIX2']-1)*hdr['CD2_2']+hdr['CRVAL2'] # log column
else:
raise Exception
# Convert X-units to frequency in GHz
xarr = xarr.as_unit('Hz', quiet=True)
gridval1 = np.interp(density, densityarr[0,:], xinds[0,:])
gridval2 = np.interp(column, columnarr[:,0], yinds[:,0])
if np.isnan(gridval1) or np.isnan(gridval2):
raise ValueError("Invalid column/density")
if scipyOK:
slices = [temperature_gridnumber] + [slice(np.floor(gv),np.floor(gv)+2) for gv in (gridval2,gridval1)]
tau = [scipy.ndimage.map_coordinates(tg[slices],np.array([[gridval2%1],[gridval1%1]]),order=1) for tg in taugrid]
else:
raise ImportError("Couldn't import scipy, therefore cannot interpolate")
# let the hyperfine module determine the hyperfine components, and pass all of them here
spec_components = [(formaldehyde_vtau(xarr.as_unit('Hz', quiet=True),
tau=float(tau[ii]), xoff_v=xoff_v, width=width,
return_tau=True, return_hyperfine_components=True, **kwargs) *
(xarr.as_unit('GHz')>minfreq[ii]) *
(xarr.as_unit('GHz')<maxfreq[ii]))
for ii in xrange(len(tau))]
# get an array of [n_lines, n_hyperfine, len(xarr)]
if return_hyperfine_components:
return np.array(spec_components).sum(axis=0)
else:
return np.sum(spec_components, axis=0).sum(axis=0)
try:
import pymodelfit
class pmfFormaldehydeModel(pymodelfit.FunctionModel1DAuto):
def f(self, x, amp0=1.0, xoff_v0=0.0,width0=1.0):
return formaldehyde(x,
amp=amp0,
xoff_v=xoff_v0,width=width0)
class pmfFormaldehydeModelVtau(pymodelfit.FunctionModel1DAuto):
def f(self, x, Tex0=1.0, tau0=0.01, xoff_v0=0.0, width0=1.0):
return formaldehyde_vtau(x,
Tex=Tex0, tau=tau0,
xoff_v=xoff_v0,width=width0)
except ImportError:
pass
| mit |
davek44/Basset | src/dev/basset_anchor.py | 1 | 12462 | #!/usr/bin/env python
from optparse import OptionParser
import copy
import math
import os
import random
import subprocess
import sys
import h5py
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from scipy.stats import spearmanr
import seaborn as sns
from sklearn.metrics import roc_auc_score, roc_curve
sns_colors = sns.color_palette('deep')
from dna_io import one_hot_set, vecs2dna
################################################################################
# basset_anchor.py
#
# Anchor a motif in the center of a set of sequences.
################################################################################
################################################################################
# main
################################################################################
def main():
usage = 'usage: %prog [options] <motif> <model_file> <test_hdf5_file>'
parser = OptionParser(usage)
parser.add_option('-d', dest='model_hdf5_file', default=None, help='Pre-computed model output as HDF5.')
parser.add_option('-f', dest='filters', default=None, help='Filters to plot length analysis [Default: %default]')
parser.add_option('-o', dest='out_dir', default='.')
parser.add_option('-p', dest='pool', default=False, action='store_true', help='Take representation after pooling [Default: %default]')
parser.add_option('-s', dest='sample', default=None, type='int', help='Sequences to sample [Default: %default]')
parser.add_option('-t', dest='targets', default=None, help='Comma-separated list of targets to analyze in more depth [Default: %default]')
(options,args) = parser.parse_args()
if len(args) != 3:
parser.error('Must provide motif, Basset model file, and test data in HDF5 format.')
else:
motif = args[0]
model_file = args[1]
test_hdf5_file = args[2]
random.seed(2)
if not os.path.isdir(options.out_dir):
os.mkdir(options.out_dir)
#################################################################
# load data
#################################################################
# load sequences
test_hdf5_in = h5py.File(test_hdf5_file, 'r')
seq_vecs = np.array(test_hdf5_in['test_in'])
seq_targets = np.array(test_hdf5_in['test_out'])
seq_headers = np.array(test_hdf5_in['test_headers'])
target_labels = np.array(test_hdf5_in['target_labels'])
test_hdf5_in.close()
#################################################################
# sample
#################################################################
if options.sample is not None and options.sample < seq_vecs.shape[0]:
# choose sampled indexes
sample_i = np.array(random.sample(xrange(seq_vecs.shape[0]), options.sample))
# filter
seq_vecs = seq_vecs[sample_i]
seq_targets = seq_targets[sample_i]
seq_headers = seq_headers[sample_i]
# create a new HDF5 file
sample_hdf5_file = '%s/sample.h5' % options.out_dir
sample_hdf5_out = h5py.File(sample_hdf5_file, 'w')
sample_hdf5_out.create_dataset('test_in', data=seq_vecs)
sample_hdf5_out.close()
# update test HDF5
test_hdf5_file = sample_hdf5_file
#################################################################
# write in motif
#################################################################
# this code must match the Torch code
seq_len = seq_vecs.shape[3]
seq_mid = math.floor(seq_len/2.0 - len(motif)/2.0) - 1
for si in range(seq_vecs.shape[0]):
for pi in range(len(motif)):
one_hot_set(seq_vecs[si], seq_mid+pi, motif[pi])
# get fasta
seq_dna = vecs2dna(seq_vecs)
#################################################################
# Torch predict
#################################################################
if options.model_hdf5_file is None:
pool_str = ''
if options.pool:
pool_str = '-pool'
options.model_hdf5_file = '%s/model_out.h5' % options.out_dir
torch_cmd = 'basset_anchor_predict.lua %s %s %s %s %s' % (pool_str, motif, model_file, test_hdf5_file, options.model_hdf5_file)
print torch_cmd
subprocess.call(torch_cmd, shell=True)
# load model output
model_hdf5_in = h5py.File(options.model_hdf5_file, 'r')
pre_preds = np.array(model_hdf5_in['pre_preds'])
preds = np.array(model_hdf5_in['preds'])
scores = np.array(model_hdf5_in['scores'])
seq_filter_outs = np.array(model_hdf5_in['filter_outs'])
pre_seq_filter_outs = np.array(model_hdf5_in['pre_filter_outs'])
model_hdf5_in.close()
# pre-process
seq_filter_means = seq_filter_outs.mean(axis=2)
filter_means = seq_filter_means.mean(axis=0)
filter_msds = seq_filter_means.std(axis=0) + 1e-6
num_seqs = seq_filter_means.shape[0]
num_filters = seq_filter_means.shape[1]
num_targets = len(target_labels)
if options.filters is None:
options.filters = range(num_filters)
else:
options.filters = [int(fi) for fi in options.filters.split(',')]
if options.targets is None:
options.targets = range(num_targets)
else:
options.targets = [int(ti) for ti in options.targets.split(',')]
#################################################################
# scatter plot prediction changes
#################################################################
sns.set(style='ticks', font_scale=1.5)
lim_eps = 0.02
for ti in options.targets:
if num_seqs > 500:
isample = np.array(random.sample(range(num_seqs), 500))
else:
isample = np.array(range(num_seqs))
plt.figure(figsize=(8,8))
g = sns.jointplot(pre_preds[isample,ti], preds[isample,ti], color='black', stat_func=None, alpha=0.5, space=0)
ax = g.ax_joint
ax.plot([0,1], [0,1], c='black', linewidth=1, linestyle='--')
ax.set_xlim((0-lim_eps, 1+lim_eps))
ax.set_ylim((0-lim_eps, 1+lim_eps))
ax.set_xlabel('Pre-insertion accessibility')
ax.set_ylabel('Post-insertion accessibility')
ax.grid(True, linestyle=':')
ax_x = g.ax_marg_x
ax_x.set_title(target_labels[ti])
plt.savefig('%s/scatter_t%d.pdf' % (options.out_dir, ti))
plt.close()
#################################################################
# plot sequences
#################################################################
for ti in options.targets:
# sort sequences by score
seqsi = np.argsort(scores[:,ti])[::-1]
# print a fasta file with uniformly sampled sequences
unif_i = np.array([int(sp) for sp in np.arange(0,num_seqs,num_seqs/200.0)])
seqsi_uniform = seqsi[unif_i]
fasta_out = open('%s/seqs_t%d.fa' % (options.out_dir,ti), 'w')
for si in seqsi_uniform:
print >> fasta_out, '>%s_gc%.2f_p%.2f\n%s' % (seq_headers[si], gc(seq_dna[si]), preds[si,ti], seq_dna[si])
fasta_out.close()
# print their filter/pos activations to a table
# this is slow and big, and I only need it when I'm trying
# to find a specific example.
table_out = open('%s/seqs_t%d_table.txt' % (options.out_dir, ti), 'w')
for si in seqsi_uniform:
for fi in range(num_filters):
for pi in range(seq_filter_outs.shape[2]):
cols = (seq_headers[si], fi, pi, seq_filter_outs[si,fi,pi])
print >> table_out, '%-25s %3d %3d %5.2f' % cols
table_out.close()
# sample fewer for heat map
unif_i = np.array([int(sp) for sp in np.arange(0,num_seqs,num_seqs/200.0)])
seqsi_uniform = seqsi[unif_i]
''' these kinda suck
# plot heat map
plt.figure()
n = 20
ax_sf = plt.subplot2grid((1,n), (0,0), colspan=n-1)
ax_ss = plt.subplot2grid((1,n), (0,n-1))
# filter heat
sf_norm = seq_filter_means[seqsi_uniform,:] - filter_means
# sf_norm = np.divide(seq_filter_means[seqsi_uniform,:] - filter_means, filter_msds)
sns.heatmap(sf_norm, vmin=-.04, vmax=.04, xticklabels=False, yticklabels=False, ax=ax_sf)
# scores heat
sns.heatmap(scores[seqsi_uniform,ti].reshape(-1,1), xticklabels=False, yticklabels=False, ax=ax_ss)
# this crashed the program, and I don't know why
# plt.tight_layout()
plt.savefig('%s/seqs_t%d.pdf' % (options.out_dir, ti))
plt.close()
'''
#################################################################
# filter mean correlations
#################################################################
# compute and print
table_out = open('%s/table.txt' % options.out_dir, 'w')
filter_target_cors = np.zeros((num_filters,num_targets))
for fi in range(num_filters):
for ti in range(num_targets):
cor, p = spearmanr(seq_filter_means[:,fi], scores[:,ti])
cols = (fi, ti, cor, p)
print >> table_out, '%-3d %3d %6.3f %6.1e' % cols
if np.isnan(cor):
cor = 0
filter_target_cors[fi,ti] = cor
table_out.close()
# plot
ftc_df = pd.DataFrame(filter_target_cors, columns=target_labels)
plt.figure()
g = sns.clustermap(ftc_df)
for tick in g.ax_heatmap.get_xticklabels():
tick.set_rotation(-45)
tick.set_horizontalalignment('left')
tick.set_fontsize(3)
for tick in g.ax_heatmap.get_yticklabels():
tick.set_fontsize(3)
plt.savefig('%s/filters_targets.pdf' % options.out_dir)
plt.close()
#################################################################
# filter position correlation
#################################################################
sns.set(style='ticks', font_scale=1.7)
table_out = open('%s/filter_pos.txt' % options.out_dir, 'w')
for fi in options.filters:
for ti in options.targets:
print 'Plotting f%d versus t%d' % (fi,ti)
# compute correlations
pos_cors = []
pos_cors_pre = []
nans = 0
for pi in range(seq_filter_outs.shape[2]):
# motif correlation
cor, p = spearmanr(seq_filter_outs[:,fi,pi], preds[:,ti])
if np.isnan(cor):
cor = 0
p = 1
nans += 1
pos_cors.append(cor)
# pre correlation
cor_pre, p_pre = spearmanr(pre_seq_filter_outs[:,fi,pi], pre_preds[:,ti])
if np.isnan(cor_pre):
cor_pre = 0
p_pre = 1
pos_cors_pre.append(cor_pre)
cols = (fi, pi, ti, cor, p, cor_pre, p_pre)
print >> table_out, '%-3d %3d %3d %6.3f %6.1e %6.3f %6.1e' % cols
if nans < 50:
# plot
# df_pc = pd.DataFrame({'Position':range(len(pos_cors)), 'Correlation':pos_cors})
plt.figure(figsize=(9,6))
plt.title(target_labels[ti])
# sns.regplot(x='Position', y='Correlation', data=df_pc, lowess=True)
plt.scatter(range(len(pos_cors)), pos_cors_pre, c=sns_colors[2], alpha=0.8, linewidths=0, label='Before motif insertion')
plt.scatter(range(len(pos_cors)), pos_cors, c=sns_colors[1], alpha=0.8, linewidths=0, label='After motif insertion')
plt.axhline(y=0, linestyle='--', c='grey', linewidth=1)
ax = plt.gca()
ax.set_xlim(0, len(pos_cors))
ax.set_xlabel('Position')
ax.set_ylabel('Activation vs Prediction Correlation')
ax.grid(True, linestyle=':')
sns.despine()
plt.legend()
plt.tight_layout()
plt.savefig('%s/f%d_t%d.pdf' % (options.out_dir,fi,ti))
plt.close()
table_out.close()
def gc(seq):
''' Return GC% '''
gc_count = 0
for nt in seq:
if nt == 'C' or nt == 'G':
gc_count += 1
return gc_count/float(len(seq))
################################################################################
# __main__
################################################################################
if __name__ == '__main__':
main()
| mit |
miloharper/neural-network-animation | matplotlib/backends/backend_wxagg.py | 11 | 5902 | from __future__ import (absolute_import, division, print_function,
unicode_literals)
import six
import matplotlib
from matplotlib.figure import Figure
from .backend_agg import FigureCanvasAgg
from . import backend_wx # already uses wxversion.ensureMinimal('2.8')
from .backend_wx import FigureManagerWx, FigureCanvasWx, \
FigureFrameWx, DEBUG_MSG, NavigationToolbar2Wx, error_msg_wx, \
draw_if_interactive, show, Toolbar, backend_version
import wx
class FigureFrameWxAgg(FigureFrameWx):
def get_canvas(self, fig):
return FigureCanvasWxAgg(self, -1, fig)
def _get_toolbar(self, statbar):
if matplotlib.rcParams['toolbar']=='toolbar2':
toolbar = NavigationToolbar2WxAgg(self.canvas)
toolbar.set_status_bar(statbar)
else:
toolbar = None
return toolbar
class FigureCanvasWxAgg(FigureCanvasAgg, FigureCanvasWx):
"""
The FigureCanvas contains the figure and does event handling.
In the wxPython backend, it is derived from wxPanel, and (usually)
lives inside a frame instantiated by a FigureManagerWx. The parent
window probably implements a wxSizer to control the displayed
control size - but we give a hint as to our preferred minimum
size.
"""
def draw(self, drawDC=None):
"""
Render the figure using agg.
"""
DEBUG_MSG("draw()", 1, self)
FigureCanvasAgg.draw(self)
self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
self._isDrawn = True
self.gui_repaint(drawDC=drawDC)
def blit(self, bbox=None):
"""
Transfer the region of the agg buffer defined by bbox to the display.
If bbox is None, the entire buffer is transferred.
"""
if bbox is None:
self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
self.gui_repaint()
return
l, b, w, h = bbox.bounds
r = l + w
t = b + h
x = int(l)
y = int(self.bitmap.GetHeight() - t)
srcBmp = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
srcDC = wx.MemoryDC()
srcDC.SelectObject(srcBmp)
destDC = wx.MemoryDC()
destDC.SelectObject(self.bitmap)
destDC.BeginDrawing()
destDC.Blit(x, y, int(w), int(h), srcDC, x, y)
destDC.EndDrawing()
destDC.SelectObject(wx.NullBitmap)
srcDC.SelectObject(wx.NullBitmap)
self.gui_repaint()
filetypes = FigureCanvasAgg.filetypes
def print_figure(self, filename, *args, **kwargs):
# Use pure Agg renderer to draw
FigureCanvasAgg.print_figure(self, filename, *args, **kwargs)
# Restore the current view; this is needed because the
# artist contains methods rely on particular attributes
# of the rendered figure for determining things like
# bounding boxes.
if self._isDrawn:
self.draw()
class NavigationToolbar2WxAgg(NavigationToolbar2Wx):
def get_canvas(self, frame, fig):
return FigureCanvasWxAgg(frame, -1, fig)
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
# in order to expose the Figure constructor to the pylab
# interface we need to create the figure here
DEBUG_MSG("new_figure_manager()", 3, None)
backend_wx._create_wx_app()
FigureClass = kwargs.pop('FigureClass', Figure)
fig = FigureClass(*args, **kwargs)
return new_figure_manager_given_figure(num, fig)
def new_figure_manager_given_figure(num, figure):
"""
Create a new figure manager instance for the given figure.
"""
frame = FigureFrameWxAgg(num, figure)
figmgr = frame.get_figure_manager()
if matplotlib.is_interactive():
figmgr.frame.Show()
return figmgr
#
# agg/wxPython image conversion functions (wxPython >= 2.8)
#
def _convert_agg_to_wx_image(agg, bbox):
"""
Convert the region of the agg buffer bounded by bbox to a wx.Image. If
bbox is None, the entire buffer is converted.
Note: agg must be a backend_agg.RendererAgg instance.
"""
if bbox is None:
# agg => rgb -> image
image = wx.EmptyImage(int(agg.width), int(agg.height))
image.SetData(agg.tostring_rgb())
return image
else:
# agg => rgba buffer -> bitmap => clipped bitmap => image
return wx.ImageFromBitmap(_WX28_clipped_agg_as_bitmap(agg, bbox))
def _convert_agg_to_wx_bitmap(agg, bbox):
"""
Convert the region of the agg buffer bounded by bbox to a wx.Bitmap. If
bbox is None, the entire buffer is converted.
Note: agg must be a backend_agg.RendererAgg instance.
"""
if bbox is None:
# agg => rgba buffer -> bitmap
return wx.BitmapFromBufferRGBA(int(agg.width), int(agg.height),
agg.buffer_rgba())
else:
# agg => rgba buffer -> bitmap => clipped bitmap
return _WX28_clipped_agg_as_bitmap(agg, bbox)
def _WX28_clipped_agg_as_bitmap(agg, bbox):
"""
Convert the region of a the agg buffer bounded by bbox to a wx.Bitmap.
Note: agg must be a backend_agg.RendererAgg instance.
"""
l, b, width, height = bbox.bounds
r = l + width
t = b + height
srcBmp = wx.BitmapFromBufferRGBA(int(agg.width), int(agg.height),
agg.buffer_rgba())
srcDC = wx.MemoryDC()
srcDC.SelectObject(srcBmp)
destBmp = wx.EmptyBitmap(int(width), int(height))
destDC = wx.MemoryDC()
destDC.SelectObject(destBmp)
destDC.BeginDrawing()
x = int(l)
y = int(int(agg.height) - t)
destDC.Blit(0, 0, int(width), int(height), srcDC, x, y)
destDC.EndDrawing()
srcDC.SelectObject(wx.NullBitmap)
destDC.SelectObject(wx.NullBitmap)
return destBmp
FigureCanvas = FigureCanvasWxAgg
FigureManager = FigureManagerWx
| mit |
untom/scikit-learn | benchmarks/bench_sample_without_replacement.py | 397 | 8008 | """
Benchmarks for sampling without replacement of integer.
"""
from __future__ import division
from __future__ import print_function
import gc
import sys
import optparse
from datetime import datetime
import operator
import matplotlib.pyplot as plt
import numpy as np
import random
from sklearn.externals.six.moves import xrange
from sklearn.utils.random import sample_without_replacement
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_sample(sampling, n_population, n_samples):
gc.collect()
# start time
t_start = datetime.now()
sampling(n_population, n_samples)
delta = (datetime.now() - t_start)
# stop time
time = compute_time(t_start, delta)
return time
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-population",
dest="n_population", default=100000, type=int,
help="Size of the population to sample from.")
op.add_option("--n-step",
dest="n_steps", default=5, type=int,
help="Number of step interval between 0 and n_population.")
default_algorithms = "custom-tracking-selection,custom-auto," \
"custom-reservoir-sampling,custom-pool,"\
"python-core-sample,numpy-permutation"
op.add_option("--algorithm",
dest="selected_algorithm",
default=default_algorithms,
type=str,
help="Comma-separated list of transformer to benchmark. "
"Default: %default. \nAvailable: %default")
# op.add_option("--random-seed",
# dest="random_seed", default=13, type=int,
# help="Seed used by the random number generators.")
(opts, args) = op.parse_args()
if len(args) > 0:
op.error("this script takes no arguments.")
sys.exit(1)
selected_algorithm = opts.selected_algorithm.split(',')
for key in selected_algorithm:
if key not in default_algorithms.split(','):
raise ValueError("Unknown sampling algorithm \"%s\" not in (%s)."
% (key, default_algorithms))
###########################################################################
# List sampling algorithm
###########################################################################
# We assume that sampling algorithm has the following signature:
# sample(n_population, n_sample)
#
sampling_algorithm = {}
###########################################################################
# Set Python core input
sampling_algorithm["python-core-sample"] = \
lambda n_population, n_sample: \
random.sample(xrange(n_population), n_sample)
###########################################################################
# Set custom automatic method selection
sampling_algorithm["custom-auto"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="auto",
random_state=random_state)
###########################################################################
# Set custom tracking based method
sampling_algorithm["custom-tracking-selection"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="tracking_selection",
random_state=random_state)
###########################################################################
# Set custom reservoir based method
sampling_algorithm["custom-reservoir-sampling"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="reservoir_sampling",
random_state=random_state)
###########################################################################
# Set custom reservoir based method
sampling_algorithm["custom-pool"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="pool",
random_state=random_state)
###########################################################################
# Numpy permutation based
sampling_algorithm["numpy-permutation"] = \
lambda n_population, n_sample: \
np.random.permutation(n_population)[:n_sample]
###########################################################################
# Remove unspecified algorithm
sampling_algorithm = dict((key, value)
for key, value in sampling_algorithm.items()
if key in selected_algorithm)
###########################################################################
# Perform benchmark
###########################################################################
time = {}
n_samples = np.linspace(start=0, stop=opts.n_population,
num=opts.n_steps).astype(np.int)
ratio = n_samples / opts.n_population
print('Benchmarks')
print("===========================")
for name in sorted(sampling_algorithm):
print("Perform benchmarks for %s..." % name, end="")
time[name] = np.zeros(shape=(opts.n_steps, opts.n_times))
for step in xrange(opts.n_steps):
for it in xrange(opts.n_times):
time[name][step, it] = bench_sample(sampling_algorithm[name],
opts.n_population,
n_samples[step])
print("done")
print("Averaging results...", end="")
for name in sampling_algorithm:
time[name] = np.mean(time[name], axis=1)
print("done\n")
# 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("Sampling algorithm performance:")
print("===============================")
print("Results are averaged over %s repetition(s)." % opts.n_times)
print("")
fig = plt.figure('scikit-learn sample w/o replacement benchmark results')
plt.title("n_population = %s, n_times = %s" %
(opts.n_population, opts.n_times))
ax = fig.add_subplot(111)
for name in sampling_algorithm:
ax.plot(ratio, time[name], label=name)
ax.set_xlabel('ratio of n_sample / n_population')
ax.set_ylabel('Time (s)')
ax.legend()
# Sort legend labels
handles, labels = ax.get_legend_handles_labels()
hl = sorted(zip(handles, labels), key=operator.itemgetter(1))
handles2, labels2 = zip(*hl)
ax.legend(handles2, labels2, loc=0)
plt.show()
| bsd-3-clause |
CVML/scikit-learn | examples/decomposition/plot_ica_vs_pca.py | 306 | 3329 | """
==========================
FastICA on 2D point clouds
==========================
This example illustrates visually in the feature space a comparison by
results using two different component analysis techniques.
:ref:`ICA` vs :ref:`PCA`.
Representing ICA in the feature space gives the view of 'geometric ICA':
ICA is an algorithm that finds directions in the feature space
corresponding to projections with high non-Gaussianity. These directions
need not be orthogonal in the original feature space, but they are
orthogonal in the whitened feature space, in which all directions
correspond to the same variance.
PCA, on the other hand, finds orthogonal directions in the raw feature
space that correspond to directions accounting for maximum variance.
Here we simulate independent sources using a highly non-Gaussian
process, 2 student T with a low number of degrees of freedom (top left
figure). We mix them to create observations (top right figure).
In this raw observation space, directions identified by PCA are
represented by orange vectors. We represent the signal in the PCA space,
after whitening by the variance corresponding to the PCA vectors (lower
left). Running ICA corresponds to finding a rotation in this space to
identify the directions of largest non-Gaussianity (lower right).
"""
print(__doc__)
# Authors: Alexandre Gramfort, Gael Varoquaux
# License: BSD 3 clause
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA, FastICA
###############################################################################
# Generate sample data
rng = np.random.RandomState(42)
S = rng.standard_t(1.5, size=(20000, 2))
S[:, 0] *= 2.
# Mix data
A = np.array([[1, 1], [0, 2]]) # Mixing matrix
X = np.dot(S, A.T) # Generate observations
pca = PCA()
S_pca_ = pca.fit(X).transform(X)
ica = FastICA(random_state=rng)
S_ica_ = ica.fit(X).transform(X) # Estimate the sources
S_ica_ /= S_ica_.std(axis=0)
###############################################################################
# Plot results
def plot_samples(S, axis_list=None):
plt.scatter(S[:, 0], S[:, 1], s=2, marker='o', zorder=10,
color='steelblue', alpha=0.5)
if axis_list is not None:
colors = ['orange', 'red']
for color, axis in zip(colors, axis_list):
axis /= axis.std()
x_axis, y_axis = axis
# Trick to get legend to work
plt.plot(0.1 * x_axis, 0.1 * y_axis, linewidth=2, color=color)
plt.quiver(0, 0, x_axis, y_axis, zorder=11, width=0.01, scale=6,
color=color)
plt.hlines(0, -3, 3)
plt.vlines(0, -3, 3)
plt.xlim(-3, 3)
plt.ylim(-3, 3)
plt.xlabel('x')
plt.ylabel('y')
plt.figure()
plt.subplot(2, 2, 1)
plot_samples(S / S.std())
plt.title('True Independent Sources')
axis_list = [pca.components_.T, ica.mixing_]
plt.subplot(2, 2, 2)
plot_samples(X / np.std(X), axis_list=axis_list)
legend = plt.legend(['PCA', 'ICA'], loc='upper right')
legend.set_zorder(100)
plt.title('Observations')
plt.subplot(2, 2, 3)
plot_samples(S_pca_ / np.std(S_pca_, axis=0))
plt.title('PCA recovered signals')
plt.subplot(2, 2, 4)
plot_samples(S_ica_ / np.std(S_ica_))
plt.title('ICA recovered signals')
plt.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.36)
plt.show()
| bsd-3-clause |
BigTone2009/sms-tools | lectures/07-Sinusoidal-plus-residual-model/plots-code/stochasticModelFrame.py | 22 | 3298 | import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import hamming, hanning, triang, blackmanharris, resample
import math
import sys, os, time
from scipy.fftpack import fft, ifft
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../../software/models/'))
import utilFunctions as UF
def stochasticModelFrame(x, w, N, stocf) :
# x: input array sound, w: analysis window, N: FFT size,
# stocf: decimation factor of mag spectrum for stochastic analysis
hN = N/2+1 # size of positive spectrum
hM = (w.size)/2 # half analysis window size
pin = hM # initialize sound pointer in middle of analysis window
fftbuffer = np.zeros(N) # initialize buffer for FFT
yw = np.zeros(w.size) # initialize output sound frame
w = w / sum(w) # normalize analysis window
#-----analysis-----
xw = x[pin-hM:pin+hM] * w # window the input sound
X = fft(xw) # compute FFT
mX = 20 * np.log10( abs(X[:hN]) ) # magnitude spectrum of positive frequencies
mXenv = resample(np.maximum(-200, mX), mX.size*stocf) # decimate the mag spectrum
pX = np.angle(X[:hN])
#-----synthesis-----
mY = resample(mXenv, hN) # interpolate to original size
pY = 2*np.pi*np.random.rand(hN) # generate phase random values
Y = np.zeros(N, dtype = complex)
Y[:hN] = 10**(mY/20) * np.exp(1j*pY) # generate positive freq.
Y[hN:] = 10**(mY[-2:0:-1]/20) * np.exp(-1j*pY[-2:0:-1]) # generate negative freq.
fftbuffer = np.real( ifft(Y) ) # inverse FFT
y = fftbuffer*N/2
return mX, pX, mY, pY, y
# example call of stochasticModel function
if __name__ == '__main__':
(fs, x) = UF.wavread('../../../sounds/ocean.wav')
w = np.hanning(1024)
N = 1024
stocf = 0.2
maxFreq = 10000.0
lastbin = N*maxFreq/fs
first = 1000
last = first+w.size
mX, pX, mY, pY, y = stochasticModelFrame(x[first:last], w, N, stocf)
plt.figure(1, figsize=(9, 7))
plt.subplot(4,1,1)
plt.plot(np.arange(first, last)/float(fs), x[first:last])
plt.axis([first/float(fs), last/float(fs), min(x[first:last]), max(x[first:last])])
plt.title('x (ocean.wav)')
plt.subplot(4,1,2)
plt.plot(float(fs)*np.arange(mX.size)/N, mX, 'r', lw=1.5, label="mX")
plt.plot(float(fs)*np.arange(mY.size)/N, mY, 'k', lw=1.5, label="mY")
plt.legend()
plt.axis([0, maxFreq, -80, max(mX)+3])
plt.title('mX + mY (stochastic approximation)')
plt.subplot(4,1,3)
plt.plot(float(fs)*np.arange(pX.size)/N, pX, 'c', lw=1.5, label="pX")
plt.plot(float(fs)*np.arange(pY.size)/N, pY-np.pi, 'k', lw=1.5, label="pY")
plt.axis([0, maxFreq, -np.pi, np.pi])
plt.legend()
plt.title('pX + pY (random phases)')
plt.subplot(4,1,4)
plt.plot(np.arange(first, last)/float(fs), y, 'b', lw=1.5)
plt.axis([first/float(fs), last/float(fs), min(y), max(y)])
plt.title('y')
plt.tight_layout()
plt.savefig('stochasticModelFrame.png')
plt.show()
| agpl-3.0 |
darinbaumgartel/dGlimpse | dGlimpse.py | 1 | 11321 | import os
import pprint
import random
import sys
import wx
import csv
import io
# The recommended way to use wx with mpl is with the WXAgg
# backend.
#
import matplotlib
matplotlib.use('WXAgg')
import numpy as np
import pylab
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
from matplotlib.backends.backend_wx import NavigationToolbar2Wx
from sklearn.svm import SVC,LinearSVC
from matplotlib.figure import Figure
import wx.lib.scrolledpanel
class ImportDatafile:
""" Getting columns of data from csv file and build a dictionary
"""
def __init__(self,infile):
self.infile = infile
def FromVerticalCSV(self):
DataSet = {}
titleset = []
ftest = open(self.infile,'r')
_n = 0
strftest = ''
for line in ftest:
strftest += line
_n += 1
if _n>1:
break
strftest = strftest.split('\n')
strftest = strftest[:-1]
if len(strftest)<2:
raise Exception("Data file "+self.infile+" is too small for analysis!")
_posdelimiters = ',;:|\t '
gooddelimiter=';'
for p in _posdelimiters:
if len(strftest[0].split(p))==len(strftest[1].split(p)):
if len(strftest[0].split(p))!=1:
gooddelimiter= p
DataSet = np.loadtxt(open(self.infile,"rb"),delimiter=gooddelimiter,skiprows=1)
DataSet = DataSet.transpose()
titleset=strftest[0].split(gooddelimiter)
return [DataSet,titleset]
########################################################################
class RandomPanel(wx.Panel):
""""""
#----------------------------------------------------------------------
def __init__(self, parent, color):
"""Constructor"""
wx.Panel.__init__(self, parent)
self.SetBackgroundColour(color)
########################################################################
class MainPanel(wx.Panel):
""""""
#----------------------------------------------------------------------
def __init__(self, parent):
"""Constructor"""
wx.Panel.__init__(self, parent)
topSplitter = wx.SplitterWindow(self)
hSplitter = wx.SplitterWindow(topSplitter)
bSplitter = wx.SplitterWindow(topSplitter)
self.panelOne = RandomPanel(hSplitter, "gray")
self.panelTwo = RandomPanel(hSplitter, "gray")
hSplitter.SplitVertically(self.panelOne, self.panelTwo,-650)
# hSplitter.SetSashGravity(0.5)
self.panelThree = RandomPanel(bSplitter, "gray")
self.panelFour = RandomPanel(bSplitter, "blue")
bSplitter.SplitVertically(self.panelThree,self.panelFour,-650)
topSplitter.SplitHorizontally(hSplitter, bSplitter,500)
# topSplitter.SetSashGravity(0.5)
self.fbutton = wx.Button(self.panelOne, -1, "Import 1st .csv",pos=(15,30),size=(120,30))
self.fbutton.Bind(wx.EVT_BUTTON, self.OnButton)
self.varlistbox = wx.ListBox(choices=[], id=wx.NewId(), name='varlistbox', parent=self.panelOne, pos=(10, 110), size=wx.Size(140, 260), style=0)
self.varlistbox.Bind(wx.EVT_LISTBOX, self.OnSelect)
self.fbutton2 = wx.Button(self.panelOne, -1, "Import 2nd .csv",pos=(15,64),size=(120,30))
self.fbutton2.Bind(wx.EVT_BUTTON, self.OnButton2)
self.varlistbox2 = wx.ListBox(choices=[], id=wx.NewId(), name='varlistbox2', parent=self.panelOne, pos=(160, 110), size=wx.Size(184, 260), style=0)
self.varlistbox2.Bind(wx.EVT_LISTBOX, self.OnSelect2)
self.possible_kernels = ['Kernel = '+k for k in ['rbf','linear']]
self.kernelchoicebox = wx.ComboBox(value=self.possible_kernels[0],choices=self.possible_kernels, id=wx.NewId(), name='kernelchoicebox', parent=self.panelThree, pos=(160, 110), size=wx.DefaultSize)
self.kernelchoicebox.Bind(wx.EVT_COMBOBOX, self.OnSelectKernel)
self.chosenkernel = self.possible_kernels[0].split('=')[-1].replace(' ','')
self.possible_cvalues = ['C = '+str((.00001*(10**_c))) for _c in range(11)]
self.cvaluechoicebox = wx.ComboBox(value=self.possible_cvalues[0],choices=self.possible_cvalues, id=wx.NewId(), name='cvaluechoicebox', parent=self.panelThree, pos=(160, 140), size=wx.DefaultSize)
self.cvaluechoicebox.Bind(wx.EVT_COMBOBOX, self.OnSelectCvalue)
self.chosencvalue = self.possible_cvalues[0].split('=')[-1].replace(' ','')
self.varlistbox3 = wx.ListBox(choices=[], id=wx.NewId(), name='varlistbox3', parent=self.panelThree, pos=(10, 110), size=wx.Size(140, 260), style=wx.LB_MULTIPLE)
self.varlistbox3.Bind(wx.EVT_LISTBOX, self.OnSelect3)
self.selindex = 0
self.compindex = 0
self.selected_variables = []
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(topSplitter, 1, wx.EXPAND)
self.SetSizer(sizer)
self.dataset2 = None
self.infile=None
self.infile2=None
def OnButton(self, evt):
# print ' OnButton selection '
dlg = wx.FileDialog(
self, message="Choose a file",
defaultDir=os.getcwd(),
defaultFile="",
style=wx.OPEN | wx.MULTIPLE | wx.CHANGE_DIR
)
self.infile = None
if dlg.ShowModal() == wx.ID_OK:
paths = dlg.GetPaths()
infile = str(paths[0])
self.infile=infile
self.fbutton.SetBackgroundColour('lightblue')
[self.dataset,self.titleset] = ImportDatafile(infile).FromVerticalCSV()
self.varlistbox.Clear()
for vartitle in self.titleset:
self.varlistbox.Append(vartitle)
self.varlistbox3.Append(vartitle)
def OnButton2(self, evt):
print ' OnButton selection '
dlg = wx.FileDialog(
self, message="Choose a file",
defaultDir=os.getcwd(),
defaultFile="",
style=wx.OPEN | wx.MULTIPLE | wx.CHANGE_DIR
)
self.infile2 = None
if dlg.ShowModal() == wx.ID_OK:
paths = dlg.GetPaths()
self.infile2 = str(paths[0])
self.fbutton2.SetBackgroundColour('pink')
[self.dataset2,self.titleset2] = ImportDatafile(self.infile2).FromVerticalCSV()
def OnSelect(self, evt):
self.selindex = evt.GetSelection()
self.varlistbox2.Clear()
for vartitle in self.titleset:
if vartitle != self.titleset[self.selindex]:
self.varlistbox2.Append('Plot vs: '+vartitle)
else:
self.varlistbox2.Append('Histogram '+self.titleset[self.selindex])
def OnSelect2(self, evt):
self.figure = Figure(figsize=(6, 4.5), dpi=100, facecolor='w', edgecolor='k')
self.mainaxis = self.figure.add_subplot(1,1,1)
self.canvas = FigureCanvas(self.panelTwo, -1, self.figure)
self.compindex = evt.GetSelection()
if self.selindex==self.compindex:
self.mainaxis.hist(self.dataset[self.selindex], 50, edgecolor='blue',alpha=0.75,label=(self.infile).split('.')[0].split('/')[-1],histtype='step')
self.mainaxis.set_xlabel(self.titleset[self.selindex])
self.mainaxis.set_ylabel('Probability')
if self.infile2!=None:
self.mainaxis.hist(self.dataset2[self.selindex], 50,edgecolor='red',alpha=0.75,label=(self.infile2).split('.')[0].split('/')[-1],histtype='step')
else:
self.mainaxis.scatter(self.dataset[self.selindex],self.dataset[self.compindex],marker='.',s=1,facecolor='0.5', edgecolor='0.5',label=(self.infile).split('.')[0].split('/')[-1])
self.mainaxis.set_xlabel(self.titleset[self.selindex])
self.mainaxis.set_ylabel(self.titleset[self.compindex])
fit_1 = np.polyfit(self.dataset[self.selindex],self.dataset[self.compindex],1)
coef_1 = np.poly1d(fit_1)
fit_2 = np.polyfit(self.dataset[self.selindex],self.dataset[self.compindex],2)
coef_2 = np.poly1d(fit_2)
x_min = min(self.dataset[self.selindex])
x_max = max(self.dataset[self.selindex])
xspace = [x_min + 0.01*(x_max-x_min)*interval for interval in range(100)]
y_1 = coef_1(xspace)
y_2 = coef_2(xspace)
# self.mainaxis.set_grid(True)
self.mainaxis.plot(xspace,y_1,'red', label='Linear Fit')
self.mainaxis.plot(xspace,y_2,'blue', label='Quadratic Fit')
legend = self.mainaxis.legend(loc='upper left', shadow=True)
for alabel in legend.get_texts():
alabel.set_fontsize('small')
self.canvas.draw()
self.canvas.resize(10,50)
def DoMVA(self):
self.figure2 = Figure(figsize=(6, 4.5), dpi=100, facecolor='w', edgecolor='k')
self.mainaxis2 = self.figure2.add_subplot(1,1,1)
self.canvas2 = FigureCanvas(self.panelFour, -1, self.figure2)
selected_variables = self.selected_variables
_S= self.dataset[selected_variables,:1000]
_B= self.dataset2[selected_variables,:1000]
v = selected_variables[0]
if self.dataset2 != None or _S.shape[0]<=1:
if len(selected_variables)==1:
v = selected_variables[0]
self.mainaxis2.hist(_S[0,:], 50,alpha=0.75,label=('Training Subset: '+self.infile.split('/')[-1].split('.')[0]),histtype='step')
self.mainaxis2.hist(_B[0,:], 50,edgecolor='red',alpha=0.75,label=('Training Subset: '+self.infile2.split('/')[-1].split('.')[0]),histtype='step')
self.mainaxis2.set_xlabel(self.titleset[self.selindex])
self.mainaxis2.set_ylabel('Probability')
legend2 = self.mainaxis2.legend(loc='upper left', shadow=True)
for alabel in legend2.get_texts():
alabel.set_fontsize('small')
if _S.shape[0]>1:
_ST = np.ones((_S.shape[-1]))
_BT = -1*np.ones((_B.shape[-1]))
_X = np.concatenate((_S,_B),axis=1)
_Y = np.concatenate((_ST,_BT),axis=0)
_X=_X.transpose()
print 'USING:',self.chosenkernel
svm = SVC(C = float(self.chosencvalue), kernel = self.chosenkernel)
svm.fit(_X,_Y)
_S_TrainHist = svm.decision_function(_S.transpose()).transpose()[0]
_B_TrainHist = svm.decision_function(_B.transpose()).transpose()[0]
self.mainaxis2.hist(_S_TrainHist, 50,alpha=0.75,label=(self.infile.split('/')[-1].split('.')[0]),histtype='step')
self.mainaxis2.hist(_B_TrainHist, 50,edgecolor='red',alpha=0.75,label=(self.infile2.split('/')[-1].split('.')[0]),histtype='step')
self.mainaxis2.axvline(x=0,color='black',linestyle='--',alpha=0.2)
_xmax = 1.2*max([_S_TrainHist.max(),_B_TrainHist.max()])
_xmin = -1.2*(abs(1.0*min([_S_TrainHist.min(),_B_TrainHist.min()])))
self.mainaxis2.axvspan(0.0, _xmax, color='blue',alpha=0.08)
self.mainaxis2.axvspan(_xmin,0.0, color='red',alpha=0.08)
self.mainaxis2.set_xlim(_xmin,_xmax )
self.mainaxis2.set_xlabel('Machine Learning Classifier')
self.mainaxis2.set_ylabel('Probability')
legend2 = self.mainaxis2.legend(loc='upper left', shadow=True)
for alabel in legend2.get_texts():
alabel.set_fontsize('small')
self.canvas2.draw()
self.canvas2.resize(10,50)
def OnSelectKernel(self,evt):
# print "Rechoosing Kernel"
self.chosenkernel = self.possible_kernels[evt.GetSelection()].split('=')[-1].replace(' ','')
# print self.chosenkernel
if len(self.selected_variables)>0:
self.DoMVA()
def OnSelectCvalue(self,evt):
self.chosencvalue = self.possible_cvalues[evt.GetSelection()].split('=')[-1].replace(' ','')
# print self.chosenkernel
if len(self.selected_variables)>0:
self.DoMVA()
def OnSelect3(self, evt):
self.selected_variables = []
for varindex in range(len(self.titleset)):
if self.varlistbox3.IsSelected(varindex):
self.selected_variables.append(varindex)
if len(self.selected_variables)>0:
self.DoMVA()
########################################################################
class MainFrame(wx.Frame):
""""""
#----------------------------------------------------------------------
def __init__(self):
"""Constructor"""
wx.Frame.__init__(self, None, title="Nested Splitters",
size=(1000,1000))
panel = MainPanel(self)
self.Show()
#----------------------------------------------------------------------
if __name__ == "__main__":
app = wx.App(False)
frame = MainFrame()
app.MainLoop() | gpl-2.0 |
platinhom/ManualHom | Coding/Python/scipy-html-0.16.1/generated/scipy-signal-fftconvolve-1.py | 1 | 1225 | # Autocorrelation of white noise is an impulse. (This is at least 100 times
# as fast as `convolve`.)
from scipy import signal
sig = np.random.randn(1000)
autocorr = signal.fftconvolve(sig, sig[::-1], mode='full')
import matplotlib.pyplot as plt
fig, (ax_orig, ax_mag) = plt.subplots(2, 1)
ax_orig.plot(sig)
ax_orig.set_title('White noise')
ax_mag.plot(np.arange(-len(sig)+1,len(sig)), autocorr)
ax_mag.set_title('Autocorrelation')
fig.tight_layout()
fig.show()
# Gaussian blur implemented using FFT convolution. Notice the dark borders
# around the image, due to the zero-padding beyond its boundaries.
# The `convolve2d` function allows for other types of image boundaries,
# but is far slower.
from scipy import misc
lena = misc.lena()
kernel = np.outer(signal.gaussian(70, 8), signal.gaussian(70, 8))
blurred = signal.fftconvolve(lena, kernel, mode='same')
fig, (ax_orig, ax_kernel, ax_blurred) = plt.subplots(1, 3)
ax_orig.imshow(lena, cmap='gray')
ax_orig.set_title('Original')
ax_orig.set_axis_off()
ax_kernel.imshow(kernel, cmap='gray')
ax_kernel.set_title('Gaussian kernel')
ax_kernel.set_axis_off()
ax_blurred.imshow(blurred, cmap='gray')
ax_blurred.set_title('Blurred')
ax_blurred.set_axis_off()
fig.show()
| gpl-2.0 |
chengsoonong/crowdastro | crowdastro/experiment/experiment_probability_vs_magnitude.py | 1 | 4019 | """Plots the magnitude features against predicted probability.
Matthew Alger
The Australian National University
2016
"""
import argparse
import collections
import logging
import h5py
import matplotlib.mlab
import matplotlib.pyplot as plt
import numpy
import scipy.interpolate
import sklearn.linear_model
import sklearn.preprocessing
def main(crowdastro_h5_path, training_h5_path):
with h5py.File(training_h5_path, 'r') as training_h5:
features = training_h5['features'].value
labels = training_h5['labels'].value
lr = sklearn.linear_model.LogisticRegression(class_weight='balanced')
lr.fit(features, labels)
with h5py.File(crowdastro_h5_path, 'r') as crowdastro_h5:
probs = crowdastro_h5['/wise/cdfs/norris_labels'].value
# probs = lr.predict_proba(features)[:, 1]
features[:, 4] = -2.5 * numpy.log10(features[:, 4])
features[:, 5] = -2.5 * numpy.log10(features[:, 5])
# Downsample.
indices = numpy.arange(features.shape[0])
numpy.random.shuffle(indices)
indices = indices[:len(indices) // 4]
w1_w2 = features[indices, 4]
w2_w3 = features[indices, 5]
xy_to_z = {}
xy_to_n = collections.defaultdict(int)
for x, y, z in zip(w2_w3, w1_w2, probs):
if (x, y) in xy_to_z:
xy_to_z[x, y] = (xy_to_z[x, y] * xy_to_n[x, y] + z) / (
xy_to_n[x, y] + 1)
xy_to_n[x, y] += 1
else:
xy_to_z[x, y] = z
xy_to_n[x, y] = 1
xs, ys, zs = [], [], []
for (x, y), z in xy_to_z.items():
xs.append(x)
ys.append(y)
zs.append(z)
x_min, x_max = numpy.percentile(xs, (2, 98))
y_min, y_max = numpy.percentile(ys, (2, 98))
res = 100
xi = numpy.linspace(x_min, x_max, res)
yi = numpy.linspace(y_min, y_max, res)
xi, yi = numpy.meshgrid(xi, yi)
rbf = scipy.interpolate.Rbf(xs, ys, zs, function='linear')
zi = rbf(xi, yi)
plt.pcolormesh(xi, yi, zi)
plt.show()
# plt.subplot(2, 2, 1)
# plt.scatter(features[labels == 0, 4], probs[labels == 0],
# color='red', marker='+')
# plt.scatter(features[labels == 1, 4], probs[labels == 1],
# color='blue', marker='+')
# plt.xlabel('w1 - w2')
# plt.ylabel('$p(z \\mid x)$')
# plt.ylim((0, 1))
# plt.subplot(2, 2, 2)
# plt.scatter(features[labels == 0, 5], probs[labels == 0],
# color='red', marker='+')
# plt.scatter(features[labels == 1, 5], probs[labels == 1],
# color='blue', marker='+')
# plt.xlabel('w2 - w3')
# plt.ylabel('$p(z \\mid x)$')
# plt.ylim((0, 1))
# plt.subplot(2, 2, 3)
# plt.scatter(features[labels == 0, 6], probs[labels == 0],
# color='red', marker='+')
# plt.scatter(features[labels == 1, 6], probs[labels == 1],
# color='blue', marker='+')
# plt.xlabel('Distance')
# plt.ylabel('$p(z \\mid x)$')
# plt.ylim((0, 1))
# plt.subplot(2, 2, 4)
# plt.scatter(features[labels == 0, 8], probs[labels == 0],
# color='red', marker='+')
# plt.scatter(features[labels == 1, 8], probs[labels == 1],
# color='blue', marker='+')
# plt.xlabel('CNN2')
# plt.ylabel('$p(z \\mid x)$')
# plt.ylim((0, 1))
# plt.show()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--crowdastro', default='data/crowdastro.h5',
help='HDF5 crowdastro data file')
parser.add_argument('--training', default='data/training.h5',
help='HDF5 training data file')
args = parser.parse_args()
logging.root.setLevel(logging.INFO)
main(args.crowdastro, args.training)
| mit |
AlexRobson/scikit-learn | examples/model_selection/plot_confusion_matrix.py | 244 | 2496 | """
================
Confusion matrix
================
Example of confusion matrix usage to evaluate the quality
of the output of a classifier on the iris data set. The
diagonal elements represent the number of points for which
the predicted label is equal to the true label, while
off-diagonal elements are those that are mislabeled by the
classifier. The higher the diagonal values of the confusion
matrix the better, indicating many correct predictions.
The figures show the confusion matrix with and without
normalization by class support size (number of elements
in each class). This kind of normalization can be
interesting in case of class imbalance to have a more
visual interpretation of which class is being misclassified.
Here the results are not as good as they could be as our
choice for the regularization parameter C was not the best.
In real life applications this parameter is usually chosen
using :ref:`grid_search`.
"""
print(__doc__)
import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm, datasets
from sklearn.cross_validation import train_test_split
from sklearn.metrics import confusion_matrix
# import some data to play with
iris = datasets.load_iris()
X = iris.data
y = iris.target
# Split the data into a training set and a test set
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
# Run classifier, using a model that is too regularized (C too low) to see
# the impact on the results
classifier = svm.SVC(kernel='linear', C=0.01)
y_pred = classifier.fit(X_train, y_train).predict(X_test)
def plot_confusion_matrix(cm, title='Confusion matrix', cmap=plt.cm.Blues):
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(iris.target_names))
plt.xticks(tick_marks, iris.target_names, rotation=45)
plt.yticks(tick_marks, iris.target_names)
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
# Compute confusion matrix
cm = confusion_matrix(y_test, y_pred)
np.set_printoptions(precision=2)
print('Confusion matrix, without normalization')
print(cm)
plt.figure()
plot_confusion_matrix(cm)
# Normalize the confusion matrix by row (i.e by the number of samples
# in each class)
cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print('Normalized confusion matrix')
print(cm_normalized)
plt.figure()
plot_confusion_matrix(cm_normalized, title='Normalized confusion matrix')
plt.show()
| bsd-3-clause |
lseman/pylspm | pylspm/tabu2.py | 1 | 3175 | # PLS-PM tabu search clustering
# Author: Laio Oriel Seman
# Brownlee, J. (2011). Clever Algorithms. Retrieved from
# http://www.cleveralgorithms.com
from random import randint, uniform
from copy import deepcopy
import numpy as np
from numpy import inf
import pandas as pd
import random
from .pylspm import PyLSpm
from .boot import PyLSboot
def stochasticTwoOpt(perm):
result = perm[:] # make a copy
size = len(result)
p1, p2 = random.randrange(0, size), random.randrange(0, size)
exclude = set([p1])
if p1 == 0:
exclude.add(size - 1)
else:
exclude.add(p1 - 1)
if p1 == size - 1:
exclude.add(0)
else:
exclude.add(p1 + 1)
while p2 in exclude:
p2 = random.randrange(0, size)
if p2 < p1:
p1, p2 = p2, p1
result[p1:p2] = reversed(result[p1:p2])
return result
def locateBestCandidate(candidates):
candidates.sort(key=lambda c: c[1])
best = candidates[0]
return best
def generateCandidates(best, tabuList):
check_tabu = None
permutation = stochasticTwoOpt(best[0])
while check_tabu == None:
if permutation in tabuList:
permutation = stochasticTwoOpt(best[0])
else:
check_tabu = 1
return permutation
def tabu(tabu_size, n_children, n_clusters, iterations, data_,
lvmodel, mvmodel, scheme, regression):
node = []
for i in range(len(data_)):
node.append(random.randrange(n_clusters))
best_ = PyLSboot(1, 8, data_, lvmodel,
mvmodel, scheme, regression, 0, 100, nclusters=n_clusters, population=[node])
best = best_.tabu()[0]
tabuList = []
for i in range(0, iterations):
print("Iteration %s" % (i + 1))
candidates = []
for index in range(0, n_children):
candidates.append(generateCandidates(best, tabuList))
fit_ = PyLSboot(len(candidates), 8, data_, lvmodel,
mvmodel, scheme, regression, 0, 100, nclusters=n_clusters, population=candidates)
fit = fit_.tabu()
bestCandidate = locateBestCandidate(fit)
if bestCandidate[1] < best[1]:
best = [bestCandidate[0], bestCandidate[1]]
tabuList.append(bestCandidate[0])
if len(tabuList) > tabu_size:
print('apagou 1')
del tabuList[0]
print("\nFitness = %s" % best[1])
print(best[0])
output = pd.DataFrame(best[0])
output.columns = ['Split']
dataSplit = pd.concat([data_, output], axis=1)
# return best clusters path matrix
results = []
for i in range(n_clusters):
dataSplited = (dataSplit.loc[dataSplit['Split']
== i]).drop('Split', axis=1)
dataSplited.index = range(len(dataSplited))
results.append(PyLSpm(dataSplited, lvmodel, mvmodel, scheme,
regression, 0, 100, HOC='true'))
print(results[i].path_matrix)
print(results[i].gof())
print(results[i].residuals()[3])
| mit |
kohr-h/odl | examples/solvers/douglas_rachford_pd_heron.py | 2 | 2172 | r"""Solves the generalized Heron problem using the Douglas-Rachford solver.
The generalized Heron problem is defined as
min_{x in R^2} sum_i d(x, Omega_i),
where d(x, Omega_i) is the distance from x to the set Omega_i. Here, the
Omega_i are given by three rectangles.
This uses the infimal convolution option of the Douglas-Rachford solver since
the problem can be written as:
min_{x in R^2} sum_i inf_{z \in Omega_i} ||x - z||.
"""
import matplotlib.pyplot as plt
import numpy as np
import odl
# Create the solution space
space = odl.rn(2)
# Define the rectangles by [minimum_corner, maximum_corner]
rectangles = [[[0, 0], [1, 1]],
[[0, 2], [1, 3]],
[[2, 2], [3, 3]]]
# The L operators are simply the identity in this case
lin_ops = [odl.IdentityOperator(space)] * len(rectangles)
# The function f in the douglas rachford solver is not needed so we set it
# to the zero function
f = odl.solvers.ZeroFunctional(space)
# g is the distance function `d(x, Omega_i)`. Here, the l2 distance.
g = [odl.solvers.L2Norm(space)] * len(rectangles)
# l are the indicator functions on the rectangles.
l = [odl.solvers.IndicatorBox(space, minp, maxp) for minp, maxp in rectangles]
# Select step size
tau = 1.0 / len(rectangles)
sigma = [1.0] * len(rectangles)
# The lam parameter can be used to accelerate the convergence rate
def lam(n):
return 1.0 + 1.0 / (n + 1)
def print_objective(x):
"""Calculate the objective value and prints it."""
value = 0
for minp, maxp in rectangles:
x_proj = np.minimum(np.maximum(x, minp), maxp)
value += (x - x_proj).norm()
print('Point = [{:.4f}, {:.4f}], Value = {:.4f}'.format(x[0], x[1], value))
# Solve
x = space.zero()
odl.solvers.douglas_rachford_pd(x, f, g, lin_ops,
tau=tau, sigma=sigma, niter=20, lam=lam,
callback=print_objective, l=l)
# plot the result
for minp, maxp in rectangles:
xp = [minp[0], maxp[0], maxp[0], minp[0], minp[0]]
yp = [minp[1], minp[1], maxp[1], maxp[1], minp[1]]
plt.plot(xp, yp)
plt.scatter(x[0], x[1])
plt.xlim(-1, 4)
plt.ylim(-1, 4)
plt.show()
| mpl-2.0 |
Natetempid/nearfield | GUI_Layout_1/GUI_Layout_1/frame_daq_measure.py | 1 | 8813 | from PyDAQmx import *
from daq9211 import *
import Tkinter as tk
import tkFileDialog
import tkMessageBox
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
from matplotlib import pyplot as plt
import matplotlib.animation as animation
import datetime
import time
import ttk
import Queue as q
class daq_measure_frame(tk.Frame):
def __init__(self, master, controller, daq9211):
tk.Frame.__init__(self, master)
self.grid_rowconfigure(1,weight=1)
self.grid_columnconfigure(0,weight=1)
self.daq9211 = daq9211
#self.test_btn = ttk.Button(self, text = 'Test', command = lambda: self.test())
#self.test_btn.pack()
self.measurement_running = False
self.plot_running = False
self.tasksetup_run = False
self.callback = None
#data queues
self.channeltime_list = [np.array([]), np.array([]), np.array([]), np.array([])]
self.channeldata_list = [np.array([]), np.array([]), np.array([]), np.array([])] #4 channels each appending data to an np.ndarray
#Header frame that includes all controls
self.headerframe = tk.Frame(self, borderwidth = 5, relief = tk.GROOVE)
self.headerframe.grid(row = 0, column = 0, sticky = 'nsew')
self.headerframe.grid_rowconfigure(0,weight = 1)
self.headerframe.grid_columnconfigure(3,weight=1)
self.headerframe.grid_columnconfigure(4,weight=1)
self.headerframe.grid_columnconfigure(5,weight=1)
#canvas for indicator
self.indicator_canvas = tk.Canvas(self.headerframe, width = 50, height = 50)
self.indicator_canvas.grid(row = 0, column = 0, sticky = 'ns')
self.indicator = self.indicator_canvas.create_oval(5,5,40,40, fill = 'red4')
self.indicatorstr = tk.StringVar()
self.indicatorstr.set('DAQ not measuring')
self.indicatorlbl = tk.Label(self.headerframe, textvariable = self.indicatorstr, font = ('tkDefaultFont', 12))
self.indicatorlbl.grid(row = 0, column = 1, sticky = 'nsew')
#Time interval
self.intervalframe = tk.Frame(self.headerframe,borderwidth = 5)
self.intervalframe.grid(row = 0, column = 2, sticky = 'nsew')
self.intervalframe.grid_rowconfigure(0,weight = 1)
self.intervalframe.grid_columnconfigure(0, weight = 1)
self.interval_lbl = tk.Label(self.intervalframe, text = 'Measurement Time Step (s)')
self.interval_lbl.grid(row = 0, column = 0)
self.intervalstr = tk.StringVar()
self.intervalstr.set('1')
self.interval = tk.Entry(self.intervalframe, textvariable = self.intervalstr, width=5)
self.interval.grid(row = 1, column = 0, sticky = 'nsew')
#Measure Button
self.measure_btn = ttk.Button(self.headerframe, text = 'Start Measurement', command = lambda:self.measure_click())
self.measure_btn.grid(row = 0, column = 3, sticky = 'nsew')
#Plot Button
self.measure_and_plot_btn = ttk.Button(self.headerframe, text = 'Start Measurement & Plot', command = lambda: self.measure_and_plot_click())
self.measure_and_plot_btn.grid(row = 0, column = 4, sticky = 'nsew')
#Reset Plot Button
self.resetbtn = ttk.Button(self.headerframe, text = 'Reset Graphs', command = lambda: self.reset_graphs())
self.resetbtn.grid(row = 0, column = 5, sticky = 'nsew')
#Plotting
self.fig = plt.Figure(figsize=(5,5))
#make plots depend on number of configured channels of the daq9211
self.axs = []
self.lines = []
for i in range(0,4):
self.axs.append(self.fig.add_subplot(2,2,i+1))
line, = self.axs[i].plot([], [], lw=2, label = 'A', color = 'b')
self.lines.append(line)
#self.axs[i].legend(bbox_to_anchor=(0, 0.02, -.102, -0.102), loc=2, ncol = 2, borderaxespad=0)
self.axs[i].set_title('Channel %d' % i)
self.canvas = FigureCanvasTkAgg(self.fig,self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
self.canvas._tkcanvas.grid(row = 1, column = 0, sticky = 'nsew')#pack(side=tk.TOP, fill=tk.BOTH, expand=True)
#Click Methods
def measure_click(self):
if self.measurement_running: #then user wants to stop the Measurement
self.stop_instrument()
self.stop_graph() #stopping the measurement also stops the graph
else: #then user wants to start the measurement without running the graph
self.start_instrument()
def measure_and_plot_click(self):
if self.measurement_running and not self.plot_running: #then user has started measuring and wants to graph
self.start_graph()
elif self.measurement_running and self.plot_running: #then user wants to stop the graph but keep the measurement going
self.stop_graph()
elif not self.measurement_running and not self.plot_running: #then user wants to start the measurement and start the graph
self.start_instrument()
self.start_graph()
#note the user cannot stop the measurement from the measure_and_plot button. To stop the Measurement, the user must click the measure_btn
def start_instrument(self):
if not self.tasksetup_run: #then I need to setup the daq channel tasks
self.run_tasksetup()
self.tasksetup_run = True
self.daq9211.measureAll(float(self.intervalstr.get()))
#change indicator
self.indicator_canvas.itemconfig(self.indicator, fill = "green2")
self.indicatorstr.set('DAQ measuring...')
#change measurement button
self.measure_btn.config(text = 'Stop Measurement & Plot')
#change measurement running state
self.measurement_running = True
def stop_instrument(self):
self.daq9211.stop_event.set()
#change indicator
self.indicator_canvas.itemconfig(self.indicator, fill = "red4")
self.indicatorstr.set('DAQ not measuring')
#change measurement button
self.measure_btn.config(text = 'Start Measurement')
while self.daq9211.thread_active:
time.sleep(0.002) #wait for the measurement to stop
#clear the measurement queue
self.daq9211.clear_queues()
#change measurement running state
self.measurement_running = False
def start_graph(self):
#change plot running state
self.plot_running = True
#change measure and plot button
self.measure_and_plot_btn.config(text = 'Stop Plot')
#disable reset button
self.resetbtn.config(state = tk.DISABLED)
#update the graph
self.update_graph()
def stop_graph(self):
#change plot running state
self.plot_running = False
#change measure and plot button
self.measure_and_plot_btn.config(text = 'Start Measurement & Plot')
#enable reset button
self.resetbtn.config(state = tk.NORMAL)
#print self.callback
if self.callback is not None:
self.after_cancel(self.callback)
def reset_graphs(self):
self.channeltime_list = [np.array([]), np.array([]), np.array([]), np.array([])]
self.channeldata_list = [np.array([]), np.array([]), np.array([]), np.array([])]
for k in range(0,4):
self.lines[k].set_data(self.channeltime_list[k], self.channeldata_list[k])
self.canvas.draw_idle()
def update_graph(self):#,i):\
#try:
def totalseconds(x):
return (x - datetime.datetime(1970,1,1)).total_seconds()
totalseconds = np.vectorize(totalseconds)
#plot by channel ID
for k in range(0,len(self.daq9211.channels)):
ID = self.daq9211.channels[k].ID #data in channel # ID is plotted on the graph # ID
while (not self.daq9211.channels[k].dataq.empty()):
data = self.daq9211.channels[k].dataq.get()
time_val = data[0]
val = data[1]
self.channeltime_list[k] = np.append(self.channeltime_list[k], time_val)
self.channeldata_list[k] = np.append(self.channeldata_list[k], val)
self.lines[ID].set_data(totalseconds(self.channeltime_list[k]), self.channeldata_list[k])
self.axs[ID].relim()
self.axs[ID].autoscale_view()
self.canvas.draw_idle()
self.callback = self.after(100, self.update_graph)
def run_tasksetup(self):
for i in range(0,len(self.daq9211.channels)):
self.daq9211.channels[i].setup_task() #setup task in each channel
#self.daq9211.data[i]] = [] #initialize data dictionary
| gpl-3.0 |
astropy/astropy | astropy/visualization/tests/test_norm.py | 7 | 11838 | # Licensed under a 3-clause BSD style license - see LICENSE.rst
from packaging.version import Version
import pytest
import numpy as np
from numpy import ma
from numpy.testing import assert_allclose, assert_equal
from astropy.utils.exceptions import AstropyDeprecationWarning
from astropy.visualization.mpl_normalize import ImageNormalize, simple_norm, imshow_norm
from astropy.visualization.interval import ManualInterval, PercentileInterval
from astropy.visualization.stretch import LogStretch, PowerStretch, SqrtStretch
from astropy.utils.compat.optional_deps import HAS_MATPLOTLIB, HAS_PLT # noqa
if HAS_MATPLOTLIB:
import matplotlib
MATPLOTLIB_LT_32 = Version(matplotlib.__version__) < Version('3.2')
DATA = np.linspace(0., 15., 6)
DATA2 = np.arange(3)
DATA2SCL = 0.5 * DATA2
DATA3 = np.linspace(-3., 3., 7)
STRETCHES = (SqrtStretch(), PowerStretch(0.5), LogStretch())
INVALID = (None, -np.inf, -1)
@pytest.mark.skipif('HAS_MATPLOTLIB')
def test_normalize_error_message():
with pytest.raises(ImportError) as exc:
ImageNormalize()
assert (exc.value.args[0] == "matplotlib is required in order to use "
"this class.")
@pytest.mark.skipif('not HAS_MATPLOTLIB')
class TestNormalize:
def test_invalid_interval(self):
with pytest.raises(TypeError):
ImageNormalize(vmin=2., vmax=10., interval=ManualInterval,
clip=True)
def test_invalid_stretch(self):
with pytest.raises(TypeError):
ImageNormalize(vmin=2., vmax=10., stretch=SqrtStretch,
clip=True)
def test_stretch_none(self):
with pytest.raises(ValueError):
ImageNormalize(vmin=2., vmax=10., stretch=None)
def test_scalar(self):
norm = ImageNormalize(vmin=2., vmax=10., stretch=SqrtStretch(),
clip=True)
norm2 = ImageNormalize(data=6, interval=ManualInterval(2, 10),
stretch=SqrtStretch(), clip=True)
assert_allclose(norm(6), 0.70710678)
assert_allclose(norm(6), norm2(6))
def test_clip(self):
norm = ImageNormalize(vmin=2., vmax=10., stretch=SqrtStretch(),
clip=True)
norm2 = ImageNormalize(DATA, interval=ManualInterval(2, 10),
stretch=SqrtStretch(), clip=True)
output = norm(DATA)
expected = [0., 0.35355339, 0.70710678, 0.93541435, 1., 1.]
assert_allclose(output, expected)
assert_allclose(output.mask, [0, 0, 0, 0, 0, 0])
assert_allclose(output, norm2(DATA))
def test_noclip(self):
norm = ImageNormalize(vmin=2., vmax=10., stretch=SqrtStretch(),
clip=False, invalid=None)
norm2 = ImageNormalize(DATA, interval=ManualInterval(2, 10),
stretch=SqrtStretch(), clip=False,
invalid=None)
output = norm(DATA)
expected = [np.nan, 0.35355339, 0.70710678, 0.93541435, 1.11803399,
1.27475488]
assert_allclose(output, expected)
assert_allclose(output.mask, [0, 0, 0, 0, 0, 0])
assert_allclose(norm.inverse(norm(DATA))[1:], DATA[1:])
assert_allclose(output, norm2(DATA))
def test_implicit_autoscale(self):
norm = ImageNormalize(vmin=None, vmax=10., stretch=SqrtStretch(),
clip=False)
norm2 = ImageNormalize(DATA, interval=ManualInterval(None, 10),
stretch=SqrtStretch(), clip=False)
output = norm(DATA)
assert norm.vmin == np.min(DATA)
assert norm.vmax == 10.
assert_allclose(output, norm2(DATA))
norm = ImageNormalize(vmin=2., vmax=None, stretch=SqrtStretch(),
clip=False)
norm2 = ImageNormalize(DATA, interval=ManualInterval(2, None),
stretch=SqrtStretch(), clip=False)
output = norm(DATA)
assert norm.vmin == 2.
assert norm.vmax == np.max(DATA)
assert_allclose(output, norm2(DATA))
def test_call_clip(self):
"""Test that the clip keyword is used when calling the object."""
data = np.arange(5)
norm = ImageNormalize(vmin=1., vmax=3., clip=False)
output = norm(data, clip=True)
assert_equal(output.data, [0, 0, 0.5, 1.0, 1.0])
assert np.all(~output.mask)
output = norm(data, clip=False)
assert_equal(output.data, [-0.5, 0, 0.5, 1.0, 1.5])
assert np.all(~output.mask)
def test_masked_clip(self):
mdata = ma.array(DATA, mask=[0, 0, 1, 0, 0, 0])
norm = ImageNormalize(vmin=2., vmax=10., stretch=SqrtStretch(),
clip=True)
norm2 = ImageNormalize(mdata, interval=ManualInterval(2, 10),
stretch=SqrtStretch(), clip=True)
output = norm(mdata)
expected = [0., 0.35355339, 1., 0.93541435, 1., 1.]
assert_allclose(output.filled(-10), expected)
assert_allclose(output.mask, [0, 0, 0, 0, 0, 0])
assert_allclose(output, norm2(mdata))
def test_masked_noclip(self):
mdata = ma.array(DATA, mask=[0, 0, 1, 0, 0, 0])
norm = ImageNormalize(vmin=2., vmax=10., stretch=SqrtStretch(),
clip=False, invalid=None)
norm2 = ImageNormalize(mdata, interval=ManualInterval(2, 10),
stretch=SqrtStretch(), clip=False,
invalid=None)
output = norm(mdata)
expected = [np.nan, 0.35355339, -10, 0.93541435, 1.11803399,
1.27475488]
assert_allclose(output.filled(-10), expected)
assert_allclose(output.mask, [0, 0, 1, 0, 0, 0])
assert_allclose(norm.inverse(norm(DATA))[1:], DATA[1:])
assert_allclose(output, norm2(mdata))
def test_invalid_data(self):
data = np.arange(25.).reshape((5, 5))
data[2, 2] = np.nan
data[1, 2] = np.inf
percent = 85.0
interval = PercentileInterval(percent)
# initialized without data
norm = ImageNormalize(interval=interval)
norm(data) # sets vmin/vmax
assert_equal((norm.vmin, norm.vmax), (1.65, 22.35))
# initialized with data
norm2 = ImageNormalize(data, interval=interval)
assert_equal((norm2.vmin, norm2.vmax), (norm.vmin, norm.vmax))
norm3 = simple_norm(data, 'linear', percent=percent)
assert_equal((norm3.vmin, norm3.vmax), (norm.vmin, norm.vmax))
assert_allclose(norm(data), norm2(data))
assert_allclose(norm(data), norm3(data))
norm4 = ImageNormalize()
norm4(data) # sets vmin/vmax
assert_equal((norm4.vmin, norm4.vmax), (0, 24))
norm5 = ImageNormalize(data)
assert_equal((norm5.vmin, norm5.vmax), (norm4.vmin, norm4.vmax))
@pytest.mark.parametrize('stretch', STRETCHES)
def test_invalid_keyword(self, stretch):
norm1 = ImageNormalize(stretch=stretch, vmin=-1, vmax=1, clip=False,
invalid=None)
norm2 = ImageNormalize(stretch=stretch, vmin=-1, vmax=1, clip=False)
norm3 = ImageNormalize(DATA3, stretch=stretch, vmin=-1, vmax=1,
clip=False, invalid=-1.)
result1 = norm1(DATA3)
result2 = norm2(DATA3)
result3 = norm3(DATA3)
assert_equal(result1[0:2], (np.nan, np.nan))
assert_equal(result2[0:2], (-1., -1.))
assert_equal(result1[2:], result2[2:])
assert_equal(result2, result3)
@pytest.mark.skipif('not HAS_MATPLOTLIB')
class TestImageScaling:
def test_linear(self):
"""Test linear scaling."""
norm = simple_norm(DATA2, stretch='linear')
assert_allclose(norm(DATA2), DATA2SCL, atol=0, rtol=1.e-5)
def test_sqrt(self):
"""Test sqrt scaling."""
norm1 = simple_norm(DATA2, stretch='sqrt')
assert_allclose(norm1(DATA2), np.sqrt(DATA2SCL), atol=0, rtol=1.e-5)
@pytest.mark.parametrize('invalid', INVALID)
def test_sqrt_invalid_kw(self, invalid):
stretch = SqrtStretch()
norm1 = simple_norm(DATA3, stretch='sqrt', min_cut=-1, max_cut=1,
clip=False, invalid=invalid)
norm2 = ImageNormalize(stretch=stretch, vmin=-1, vmax=1, clip=False,
invalid=invalid)
assert_equal(norm1(DATA3), norm2(DATA3))
def test_power(self):
"""Test power scaling."""
power = 3.0
norm = simple_norm(DATA2, stretch='power', power=power)
assert_allclose(norm(DATA2), DATA2SCL ** power, atol=0, rtol=1.e-5)
def test_log(self):
"""Test log10 scaling."""
norm = simple_norm(DATA2, stretch='log')
ref = np.log10(1000 * DATA2SCL + 1.0) / np.log10(1001.0)
assert_allclose(norm(DATA2), ref, atol=0, rtol=1.e-5)
def test_log_with_log_a(self):
"""Test log10 scaling with a custom log_a."""
log_a = 100
norm = simple_norm(DATA2, stretch='log', log_a=log_a)
ref = np.log10(log_a * DATA2SCL + 1.0) / np.log10(log_a + 1)
assert_allclose(norm(DATA2), ref, atol=0, rtol=1.e-5)
def test_asinh(self):
"""Test asinh scaling."""
norm = simple_norm(DATA2, stretch='asinh')
ref = np.arcsinh(10 * DATA2SCL) / np.arcsinh(10)
assert_allclose(norm(DATA2), ref, atol=0, rtol=1.e-5)
def test_asinh_with_asinh_a(self):
"""Test asinh scaling with a custom asinh_a."""
asinh_a = 0.5
norm = simple_norm(DATA2, stretch='asinh', asinh_a=asinh_a)
ref = np.arcsinh(DATA2SCL / asinh_a) / np.arcsinh(1. / asinh_a)
assert_allclose(norm(DATA2), ref, atol=0, rtol=1.e-5)
def test_min(self):
"""Test linear scaling."""
norm = simple_norm(DATA2, stretch='linear', min_cut=1., clip=True)
assert_allclose(norm(DATA2), [0., 0., 1.], atol=0, rtol=1.e-5)
def test_percent(self):
"""Test percent keywords."""
norm = simple_norm(DATA2, stretch='linear', percent=99., clip=True)
assert_allclose(norm(DATA2), DATA2SCL, atol=0, rtol=1.e-5)
norm2 = simple_norm(DATA2, stretch='linear', min_percent=0.5,
max_percent=99.5, clip=True)
assert_allclose(norm(DATA2), norm2(DATA2), atol=0, rtol=1.e-5)
def test_invalid_stretch(self):
"""Test invalid stretch keyword."""
with pytest.raises(ValueError):
simple_norm(DATA2, stretch='invalid')
@pytest.mark.skipif('not HAS_PLT')
def test_imshow_norm():
import matplotlib.pyplot as plt
image = np.random.randn(10, 10)
ax = plt.subplot(label='test_imshow_norm')
imshow_norm(image, ax=ax)
with pytest.raises(ValueError):
# X and data are the same, can't give both
imshow_norm(image, X=image, ax=ax)
with pytest.raises(ValueError):
# illegal to manually pass in normalization since that defeats the point
imshow_norm(image, ax=ax, norm=ImageNormalize())
imshow_norm(image, ax=ax, vmin=0, vmax=1)
with pytest.warns(AstropyDeprecationWarning):
# Note that the following is deprecated in Matplotlib 3.2
if MATPLOTLIB_LT_32:
# vmin/vmax "shadow" the MPL versions, so imshow_only_kwargs allows direct-setting
imshow_norm(image, ax=ax, imshow_only_kwargs=dict(vmin=0, vmax=1))
# but it should fail for an argument that is not in ImageNormalize
with pytest.raises(ValueError):
imshow_norm(image, ax=ax, imshow_only_kwargs=dict(cmap='jet'))
# make sure the pyplot version works
imres, norm = imshow_norm(image, ax=None)
assert isinstance(norm, ImageNormalize)
plt.close('all')
| bsd-3-clause |
CFIS-Octarine/octarine | src/ossos_tests/test_ossos/test_fitsviewer/test_displayable.py | 2 | 7722 | __author__ = "David Rusk <[email protected]>"
import unittest
from astropy.io.fits.hdu.hdulist import HDUList
import matplotlib.pyplot as plt
from hamcrest import assert_that, close_to, equal_to, none
from mock import Mock, MagicMock
from ossos import astrom
from ossos.downloads.cutouts.source import SourceCutout
from ossos.downloads.cutouts.grid import CutoutGrid
from ossos.fitsviewer.colormap import clip
from ossos.fitsviewer.displayable import (DisplayableImageSinglet,
DisplayableImageTriplet,
ImageSinglet)
from ossos.fitsviewer import displayable
class ImageSingletTest(unittest.TestCase):
def setUp(self):
mainhdu = Mock()
mainhdu.data.shape = (100, 100)
self.hdulist = [mainhdu]
fig = plt.figure()
self.displayable = ImageSinglet(self.hdulist, fig, [0, 0, 1, 1])
def test_draw_one_circle(self):
assert_that(self.displayable.marker, none())
cx = 1
cy = 2
cr = 3
self.displayable.place_marker(cx, cy, cr)
assert_that(self.displayable.marker.center, equal_to((cx, cy)))
assert_that(self.displayable.marker.radius, equal_to(cr))
def test_draw_second_circle_removes_first(self):
c1x = 1
c1y = 2
c1r = 3
self.displayable.place_marker(c1x, c1y, c1r)
assert_that(self.displayable.marker.center, equal_to((c1x, c1y)))
assert_that(self.displayable.marker.radius, equal_to(c1r))
c2x = 4
c2y = 5
c2r = 6
self.displayable.place_marker(c2x, c2y, c2r)
assert_that(self.displayable.marker.center, equal_to((c2x, c2y)))
assert_that(self.displayable.marker.radius, equal_to(c2r))
def test_toggle_reticule_notifies_display_changed(self):
self.displayable.place_marker(10, 10, 10)
refresh_handler = Mock()
self.displayable.display_changed.connect(refresh_handler)
self.displayable.toggle_reticule()
refresh_handler.assert_called_once_with()
class DisplayableImageSingletTest(unittest.TestCase):
def setUp(self):
self.singlet = DisplayableImageSinglet(MagicMock())
def mock_image_singlet(self):
image_singlet = Mock(spec=ImageSinglet)
self.singlet.image_singlet = image_singlet
return image_singlet
def test_reset_colormap(self):
image_singlet = self.mock_image_singlet()
self.singlet.reset_colormap()
image_singlet.reset_colormap.assert_called_once_with()
def test_toggle_reticule(self):
image_singlet = self.mock_image_singlet()
self.singlet.toggle_reticule()
image_singlet.toggle_reticule.assert_called_once_with()
class DisplayableImageTripletTest(unittest.TestCase):
def setUp(self):
source = Mock(spec=astrom.Source)
source.num_readings.return_value = 3
def mock_hdulist():
return MagicMock(spec=HDUList)
grid = CutoutGrid(source)
self.hdulist00 = mock_hdulist()
self.hdulist01 = mock_hdulist()
self.hdulist02 = mock_hdulist()
self.hdulist10 = mock_hdulist()
self.hdulist11 = mock_hdulist()
self.hdulist12 = mock_hdulist()
self.hdulist20 = mock_hdulist()
self.hdulist21 = mock_hdulist()
self.hdulist22 = mock_hdulist()
def mock_cutout(hdulist):
cutout = Mock(spec=SourceCutout)
cutout.hdulist = hdulist
return cutout
grid.add_cutout(mock_cutout(self.hdulist00), 0, 0)
grid.add_cutout(mock_cutout(self.hdulist01), 0, 1)
grid.add_cutout(mock_cutout(self.hdulist02), 0, 2)
grid.add_cutout(mock_cutout(self.hdulist10), 1, 0)
grid.add_cutout(mock_cutout(self.hdulist11), 1, 1)
grid.add_cutout(mock_cutout(self.hdulist12), 1, 2)
grid.add_cutout(mock_cutout(self.hdulist20), 2, 0)
grid.add_cutout(mock_cutout(self.hdulist21), 2, 1)
grid.add_cutout(mock_cutout(self.hdulist22), 2, 2)
self.grid = grid
def test_frames_have_correct_hdulists(self):
displayable = DisplayableImageTriplet(self.grid)
def get_hdulist(frame_index, time_index):
return displayable.get_singlet(frame_index, time_index).hdulist
assert_that(get_hdulist(0, 0), equal_to(self.hdulist00))
assert_that(get_hdulist(0, 1), equal_to(self.hdulist01))
assert_that(get_hdulist(0, 2), equal_to(self.hdulist02))
assert_that(get_hdulist(1, 0), equal_to(self.hdulist10))
assert_that(get_hdulist(1, 1), equal_to(self.hdulist11))
assert_that(get_hdulist(1, 2), equal_to(self.hdulist12))
assert_that(get_hdulist(2, 0), equal_to(self.hdulist20))
assert_that(get_hdulist(2, 1), equal_to(self.hdulist21))
assert_that(get_hdulist(2, 2), equal_to(self.hdulist22))
class UtilityTest(unittest.TestCase):
def assert_close(self, expected, actual):
assert_that(expected, close_to(actual, 0.0001))
def test_clip_in_range(self):
assert_that(clip(0.5, 0, 1), equal_to(0.5))
def test_clip_below_range(self):
assert_that(clip(-0.5, 0, 1), equal_to(0.0))
def test_clip_above_range(self):
assert_that(clip(1.5, 0, 1), equal_to(1.0))
def test_get_rect_first_frame_first_time_top_left(self):
[left, bottom, width, height] = displayable.get_rect((3, 3), 0, 0,
border=0, spacing=0)
assert_that(left, equal_to(0))
assert_that(bottom, equal_to(2./3))
assert_that(width, equal_to(1./3))
assert_that(height, equal_to(1./3))
def test_get_rect_last_frame_last_time_bottom_right(self):
[left, bottom, width, height] = displayable.get_rect((3, 3), 2, 2,
border=0, spacing=0)
assert_that(left, equal_to(2./3))
assert_that(bottom, equal_to(0))
assert_that(width, equal_to(1./3))
assert_that(height, equal_to(1./3))
def test_get_rect_last_frame_first_time_bottom_left(self):
[left, bottom, width, height] = displayable.get_rect((3, 3), 2, 0,
border=0, spacing=0)
assert_that(left, equal_to(0))
assert_that(bottom, equal_to(0))
assert_that(width, equal_to(1./3))
assert_that(height, equal_to(1./3))
def test_get_rect_last_frame_first_time_with_border(self):
[left, bottom, width, height] = displayable.get_rect((3, 3), 2, 0,
border=0.05, spacing=0)
assert_that(left, equal_to(0.05))
assert_that(bottom, equal_to(0.05))
assert_that(width, equal_to(0.3))
assert_that(height, equal_to(0.3))
def test_get_rect_mid_frame_first_time_with_spacing(self):
[left, bottom, width, height] = displayable.get_rect((3, 3), 1, 0,
border=0, spacing=0.05)
assert_that(left, equal_to(0))
assert_that(bottom, equal_to(0.35))
assert_that(width, equal_to(0.3))
assert_that(height, equal_to(0.3))
def test_get_rect_mid_frame_first_time_with_spacing_and_border(self):
[left, bottom, width, height] = displayable.get_rect((3, 3), 1, 0,
border=0.025, spacing=0.025)
self.assert_close(left, 0.025)
self.assert_close(bottom, 0.35)
self.assert_close(width, 0.3)
self.assert_close(height, 0.3)
if __name__ == '__main__':
unittest.main()
| gpl-3.0 |
d-mittal/pystruct | pystruct/learners/subgradient_latent_ssvm.py | 4 | 10991 | ######################
# (c) 2012 Andreas Mueller <[email protected]>
# License: BSD 3-clause
#
from time import time
import numpy as np
from sklearn.externals.joblib import Parallel, delayed, cpu_count
from sklearn.utils import gen_even_slices
from .subgradient_ssvm import SubgradientSSVM
from ..utils import find_constraint_latent
class SubgradientLatentSSVM(SubgradientSSVM):
"""Latent Variable Structured SVM solver using subgradient descent.
Implements a margin rescaled with l1 slack penalty.
By default, a constant learning rate is used.
It is also possible to use the adaptive learning rate found by AdaGrad.
This class implements online subgradient descent. If n_jobs != 1,
small batches of size n_jobs are used to exploit parallel inference.
If inference is fast, use n_jobs=1.
Parameters
----------
model : StructuredModel
Object containing model structure. Has to implement
`loss`, `inference` and `loss_augmented_inference`.
max_iter : int, default=100
Maximum number of passes over dataset to find constraints and perform
updates.
C : float, default=1.
Regularization parameter
verbose : int, default=0
Verbosity.
learning_rate : float or 'auto', default='auto'
Learning rate used in subgradient descent. If 'auto', the pegasos
schedule is used, which starts with ``learning_rate = n_samples * C``.
momentum : float, default=0.0
Momentum used in subgradient descent.
n_jobs : int, default=1
Number of parallel jobs for inference. -1 means as many as cpus.
show_loss_every : int, default=0
Controlls how often the hamming loss is computed (for monitoring
purposes). Zero means never, otherwise it will be computed very
show_loss_every'th epoch.
decay_exponent : float, default=1
Exponent for decaying learning rate. Effective learning rate is
``learning_rate / (decay_t0 + t)** decay_exponent``. Zero means no decay.
decay_t0 : float, default=10
Offset for decaying learning rate. Effective learning rate is
``learning_rate / (decay_t0 + t)** decay_exponent``.
break_on_no_constraints : bool, default=True
Break when there are no new constraints found.
averaging : string, default=None
Whether and how to average weights. Possible options are 'linear', 'squared' and None.
The string reflects the weighting of the averaging:
- linear: ``w_avg ~ w_1 + 2 * w_2 + ... + t * w_t``
- squared: ``w_avg ~ w_1 + 4 * w_2 + ... + t**2 * w_t``
Uniform averaging is not implemented as it is worse than linear
weighted averaging or no averaging.
Attributes
----------
w : nd-array, shape=(model.size_joint_feature,)
The learned weights of the SVM.
``loss_curve_`` : list of float
List of loss values if show_loss_every > 0.
``objective_curve_`` : list of float
Primal objective after each pass through the dataset.
``timestamps_`` : list of int
Total training time stored before each iteration.
"""
def __init__(self, model, max_iter=100, C=1.0, verbose=0, momentum=0.,
learning_rate='auto', n_jobs=1,
show_loss_every=0, decay_exponent=1, decay_t0=10,
break_on_no_constraints=True, logger=None, averaging=None):
SubgradientSSVM.__init__(
self, model, max_iter, C, verbose=verbose, n_jobs=n_jobs,
show_loss_every=show_loss_every, decay_exponent=decay_exponent,
momentum=momentum, learning_rate=learning_rate,
break_on_no_constraints=break_on_no_constraints, logger=logger,
decay_t0=decay_t0, averaging=averaging)
def fit(self, X, Y, H_init=None, warm_start=False, initialize=True):
"""Learn parameters using subgradient descent.
Parameters
----------
X : iterable
Traing instances. Contains the structured input objects.
No requirement on the particular form of entries of X is made.
Y : iterable
Training labels. Contains the strctured labels for inputs in X.
Needs to have the same length as X.
constraints : None
Discarded. Only for API compatibility currently.
warm_start : boolean, default=False
Whether to restart a previous fit.
initialize : boolean, default=True
Whether to initialize the model for the data.
Leave this true except if you really know what you are doing.
"""
if self.verbose > 0:
print("Training latent subgradient structural SVM")
if initialize:
self.model.initialize(X, Y)
self.grad_old = np.zeros(self.model.size_joint_feature)
if not warm_start:
self.w = getattr(self, "w", np.random.normal(
0, 1, size=self.model.size_joint_feature))
self.timestamps_ = [time()]
self.objective_curve_ = []
if self.learning_rate == "auto":
self.learning_rate_ = self.C * len(X)
else:
self.learning_rate_ = self.learning_rate
else:
# hackety hack
self.timestamps_[0] = time() - self.timestamps_[-1]
w = self.w.copy()
n_samples = len(X)
try:
# catch ctrl+c to stop training
for iteration in range(self.max_iter):
self.timestamps_.append(time() - self.timestamps_[0])
positive_slacks = 0
objective = 0.
#verbose = max(0, self.verbose - 3)
if self.n_jobs == 1:
# online learning
for x, y in zip(X, Y):
h = self.model.latent(x, y, w)
h_hat = self.model.loss_augmented_inference(
x, h, w, relaxed=True)
delta_joint_feature = (
self.model.joint_feature(x, h)
- self.model.joint_feature(x, h_hat))
slack = (-np.dot(delta_joint_feature, w)
+ self.model.loss(h, h_hat))
objective += np.maximum(slack, 0)
if slack > 0:
positive_slacks += 1
w = self._solve_subgradient(delta_joint_feature, n_samples, w)
else:
#generate batches of size n_jobs
#to speed up inference
if self.n_jobs == -1:
n_jobs = cpu_count()
else:
n_jobs = self.j_jobs
n_batches = int(np.ceil(float(len(X)) / n_jobs))
slices = gen_even_slices(n_samples, n_batches)
for batch in slices:
X_b = X[batch]
Y_b = Y[batch]
verbose = self.verbose - 1
candidate_constraints = Parallel(
n_jobs=self.n_jobs,
verbose=verbose)(delayed(find_constraint_latent)(
self.model, x, y, w)
for x, y in zip(X_b, Y_b))
djoint_feature = np.zeros(self.model.size_joint_feature)
for x, y, constraint in zip(X_b, Y_b,
candidate_constraints):
y_hat, delta_joint_feature, slack, loss = constraint
objective += slack
djoint_feature += delta_joint_feature
if slack > 0:
positive_slacks += 1
djoint_feature /= float(len(X_b))
w = self._solve_subgradient(djoint_feature, n_samples, w)
# some statistics
objective *= self.C
objective += np.sum(self.w ** 2) / 2.
if positive_slacks == 0:
print("No additional constraints")
if self.break_on_no_constraints:
break
if self.verbose > 0:
print(self)
print("iteration %d" % iteration)
print("positive slacks: %d, "
"objective: %f" %
(positive_slacks, objective))
self.objective_curve_.append(objective)
if self.verbose > 2:
print(self.w)
self._compute_training_loss(X, Y, iteration)
if self.logger is not None:
self.logger(self, iteration)
except KeyboardInterrupt:
pass
self.timestamps_.append(time() - self.timestamps_[0])
self.objective_curve_.append(self._objective(X, Y))
if self.logger is not None:
self.logger(self, 'final')
if self.verbose:
if self.objective_curve_:
print("final objective: %f" % self.objective_curve_[-1])
if self.verbose and self.n_jobs == 1:
print("calls to inference: %d" % self.model.inference_calls)
return self
def predict(self, X):
prediction = SubgradientSSVM.predict(self, X)
return [self.model.label_from_latent(h) for h in prediction]
def predict_latent(self, X):
return SubgradientSSVM.predict(self, X)
def score(self, X, Y):
"""Compute score as 1 - loss over whole data set.
Returns the average accuracy (in terms of model.loss)
over X and Y.
Parameters
----------
X : iterable
Evaluation data.
Y : iterable
True labels.
Returns
-------
score : float
Average of 1 - loss over training examples.
"""
if hasattr(self.model, 'batch_loss'):
losses = self.model.batch_loss(
Y, self.model.batch_inference(X, self.w))
else:
losses = [self.model.loss(y, self.model.inference(y, self.w))
for y, y_pred in zip(Y, self.predict(X))]
max_losses = [self.model.max_loss(y) for y in Y]
return 1. - np.sum(losses) / float(np.sum(max_losses))
def _objective(self, X, Y):
constraints = Parallel(
n_jobs=self.n_jobs,
verbose=self.verbose - 1)(delayed(find_constraint_latent)(
self.model, x, y, self.w)
for x, y in zip(X, Y))
slacks = list(zip(*constraints))[2]
slacks = np.maximum(slacks, 0)
objective = np.sum(slacks) * self.C + np.sum(self.w ** 2) / 2.
return objective
| bsd-2-clause |
shangwuhencc/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 |
gagneurlab/concise | concise/data/attract.py | 2 | 1756 | """Helper functions for loading data from the attract db
"""
from concise.utils.pwm import PWM, load_motif_db
import pandas as pd
from pkg_resources import resource_filename
ATTRACT_METADTA = resource_filename('concise', 'resources/attract_metadata.txt')
ATTRACT_PWM = resource_filename('concise', 'resources/attract_pwm.txt')
def get_metadata():
"""
Get pandas.DataFrame with metadata about the Attract PWM's. Columns:
- PWM_id (id of the PWM - pass to get_pwm_list() for getting the pwm
- Gene_name
- Gene_id
- Mutated (if the target gene is mutated)
- Organism
- Motif (concsensus motif)
- Len (lenght of the motif)
- Experiment_description(when available)
- Database (Database from where the motifs were extracted PDB: Protein data bank, C: Cisbp-RNA, R:RBPDB, S: Spliceaid-F, AEDB:ASD)
- Pubmed (pubmed ID)
- Experiment (type of experiment; short description)
- Family (domain)
- Score (Qscore refer to the paper)
"""
dt = pd.read_table(ATTRACT_METADTA)
dt.rename(columns={"Matrix_id": "PWM_id"}, inplace=True)
# put to firt place
cols = ['PWM_id'] + [col for col in dt if col != 'PWM_id']
# rename Matrix_id to PWM_id
return dt[cols]
def get_pwm_list(pwm_id_list, pseudocountProb=0.0001):
"""Get a list of Attract PWM's.
# Arguments
pwm_id_list: List of id's from the `PWM_id` column in `get_metadata()` table
pseudocountProb: Added pseudocount probabilities to the PWM
# Returns
List of `concise.utils.pwm.PWM` instances.
"""
l = load_motif_db(ATTRACT_PWM)
l = {k.split()[0]: v for k, v in l.items()}
pwm_list = [PWM(l[str(m)] + pseudocountProb, name=m) for m in pwm_id_list]
return pwm_list
| mit |
kaz-Anova/ensemble_amazon | XGBoostClassifier.py | 1 | 8099 | # -*- coding: utf-8 -*-
"""
Created on oct 20 23:15:24 2015
@author: marios
Script that makes Xgboost scikit-like.
The initial version of the script came from Guido Tapia (or such is his kaggle name!). I have modified it quite a bit though.
the github from where this was retrieved was : https://github.com/gatapia/py_ml_utils
He has done excellent job in making many commonly used algorithms scikit-like
"""
from sklearn.base import BaseEstimator, ClassifierMixin
import sys
from sklearn.cross_validation import StratifiedKFold
import xgboost as xgb
import numpy as np
from scipy.sparse import csr_matrix
class XGBoostClassifier(BaseEstimator, ClassifierMixin):
def __init__(self, silent=True,
use_buffer=True, num_round=10,num_parallel_tree=1, ntree_limit=0,
nthread=None, booster='gbtree',
eta=0.3, gamma=0.01,
max_depth=6, min_child_weight=1, subsample=1,
colsample_bytree=1,
l=0, alpha=0, lambda_bias=0, objective='reg:linear',
eval_metric='logloss', seed=0, num_class=None,
max_delta_step=0,classes_=None ,
colsample_bylevel=1.0 , sketch_eps=0.1 , sketch_ratio=2.0 ,
opt_dense_col=1, size_leaf_vector=0.0, min_split_loss=0.0,
cache_opt=1, default_direction =0 , k_folds=0 ,early_stopping_rounds=200
):
assert booster in ['gbtree', 'gblinear']
assert objective in ['reg:linear', 'reg:logistic',
'binary:logistic', 'binary:logitraw', 'multi:softmax',
'multi:softprob', 'rank:pairwise','count:poisson']
assert eval_metric in [ 'rmse', 'mlogloss', 'logloss', 'error',
'merror', 'auc', 'ndcg', 'map', 'ndcg@n', 'map@n', 'kappa']
if eval_metric=='kappa':
booster='gblinear'
self.silent = silent
self.use_buffer = use_buffer
self.num_round = num_round
self.ntree_limit = ntree_limit
self.nthread = nthread
self.booster = booster
# Parameter for Tree Booster
self.eta=eta
self.gamma=gamma
self.max_depth=max_depth
self.min_child_weight=min_child_weight
self.subsample=subsample
self.colsample_bytree=colsample_bytree
self.colsample_bylevel=colsample_bylevel
self.max_delta_step=max_delta_step
self.num_parallel_tree=num_parallel_tree
self.min_split_loss=min_split_loss
self.size_leaf_vector=size_leaf_vector
self.default_direction=default_direction
self.opt_dense_col=opt_dense_col
self.sketch_eps=sketch_eps
self.sketch_ratio=sketch_ratio
self.k_folds=k_folds
self.k_models=[]
self.early_stopping_rounds=early_stopping_rounds
# Parameter for Linear Booster
self.l=l
self.alpha=alpha
self.lambda_bias=lambda_bias
# Misc
self.objective=objective
self.eval_metric=eval_metric
self.seed=seed
self.num_class = num_class
self.n_classes_ =num_class
self.classes_=classes_
def set_params(self,random_state=1):
self.seed=random_state
def build_matrix(self, X, opt_y=None, weighting=None):
if opt_y==None:
if weighting==None:
return xgb.DMatrix(csr_matrix(X), missing =-999.0)
else :
#scale weight
sumtotal=float(X.shape[0])
sumweights=np.sum(weighting)
for s in range(0,len(weighting)):
weighting[s]*=sumtotal/sumweights
return xgb.DMatrix(csr_matrix(X), missing =-999.0, weight=weighting)
else:
if weighting==None:
return xgb.DMatrix(csr_matrix(X), label=np.array(opt_y), missing =-999.0)
else :
sumtotal=float(X.shape[0])
sumweights=np.sum(weighting)
for s in range(0,len(weighting)):
weighting[s]*=sumtotal/sumweights
return xgb.DMatrix(csr_matrix(X), label=np.array(opt_y), missing =-999.0, weight=weighting)
def fit(self, X, y,sample_weight=None):
self.k_models=[]
X1 = self.build_matrix(X, y,weighting= sample_weight)#sample_weight)
param = {}
param['booster']=self.booster
param['objective'] = self.objective
param['bst:eta'] = self.eta
param['seed']= self.seed
param['bst:max_depth'] = self.max_depth
if self.eval_metric!='kappa':
param['eval_metric'] = self.eval_metric
param['bst:min_child_weight']= self.min_child_weight
param['silent'] = 1
param['nthread'] = self.nthread
param['bst:subsample'] = self.subsample
param['gamma'] = self.gamma
param['colsample_bytree']= self.colsample_bytree
param['num_parallel_tree']= self.num_parallel_tree
param['colsample_bylevel']= self.colsample_bylevel
#param['min_split_loss']=self.min_split_loss
param['default_direction']=self.default_direction
param['opt_dense_col']=self.opt_dense_col
param['sketch_eps']=self.sketch_eps
param['sketch_ratio']=self.sketch_ratio
param['size_leaf_vector']=self.size_leaf_vector
if self.num_class is not None:
param['num_class']= self.num_class
if self.k_folds <2:
self.bst = xgb.train(param.items(), X1, self.num_round)
else :
number_of_folds=self.k_folds
kfolder2=StratifiedKFold(y, n_folds=number_of_folds,shuffle=True, random_state=self.seed)
## we split 64-16 5 times to make certain all the data has been use in modelling at least once
for train_indexnew, test_indexnew in kfolder2:
if sample_weight==None:
dtrain = xgb.DMatrix(X[train_indexnew], label=y[train_indexnew])
dtvalid = xgb.DMatrix(X[test_indexnew], label=y[test_indexnew])
else :
dtrain = xgb.DMatrix(X[train_indexnew], label=y[train_indexnew], weight=sample_weight[train_indexnew])
dtvalid = xgb.DMatrix(X[test_indexnew], label=y[test_indexnew], weight=sample_weight[test_indexnew])
watchlist = [(dtrain, 'train'), (dtvalid, 'valid')]
gbdt = xgb.train(param.items(), dtrain, self.num_round, watchlist, verbose_eval=False, early_stopping_rounds=self.early_stopping_rounds)#, verbose_eval=250) #, early_stopping_rounds=250, verbose_eval=250)
#predsnew = gbdt.predict(dtest, ntree_limit=gbdt.best_iteration)
self.k_models.append(gbdt)
return self
def predict(self, X):
if self.k_models!=None and len(self.k_models)<2:
X1 = self.build_matrix(X)
return self.bst.predict(X1)
else :
dtest = xgb.DMatrix(X)
preds= [0.0 for k in X.shape[0]]
for gbdt in self.k_models:
predsnew = gbdt.predict(dtest, ntree_limit=(gbdt.best_iteration+1)*self.num_parallel_tree)
for g in range (0, predsnew.shape[0]):
preds[g]+=predsnew[g]
for g in range (0, len(preds)):
preds[g]/=float(len(self.k_models))
def predict_proba(self, X):
try:
rows=(X.shape[0])
except:
rows=len(X)
X1 = self.build_matrix(X)
if self.k_models!=None and len(self.k_models)<2:
predictions = self.bst.predict(X1)
else :
dtest = xgb.DMatrix(X)
predictions= None
for gbdt in self.k_models:
predsnew = gbdt.predict(dtest, ntree_limit=(gbdt.best_iteration+1)*self.num_parallel_tree)
if predictions==None:
predictions=predsnew
else:
for g in range (0, predsnew.shape[0]):
predictions[g]+=predsnew[g]
for g in range (0, len(predictions)):
predictions[g]/=float(len(self.k_models))
predictions=np.array(predictions)
if self.objective == 'multi:softprob': return predictions.reshape( rows, self.num_class)
return np.vstack([1 - predictions, predictions]).T
| apache-2.0 |
kastnerkyle/dagbldr | examples/sine_rnn/sine_rnn.py | 2 | 3646 | #!/usr/bin/env python
import numpy as np
import theano
from theano import tensor
from dagbldr.nodes import linear
from dagbldr.nodes import simple_fork
from dagbldr.nodes import simple
from dagbldr import get_params
from dagbldr.utils import create_checkpoint_dict
from dagbldr.optimizers import sgd
from dagbldr.training import TrainingLoop
from dagbldr.datasets import minibatch_iterator
def make_sines(n_timesteps, n_offsets, harmonic=False, square=False):
# Generate sinewaves offset in phase
n_full = n_timesteps
d1 = 3 * np.arange(n_full) / (2 * np.pi)
d2 = 3 * np.arange(n_offsets) / (2 * np.pi)
full_sines = np.sin(np.array([d1] * n_offsets).T + d2).astype("float32")
# Uncomment to add harmonics
if harmonic:
full_sines += np.sin(np.array([1.7 * d1] * n_offsets).T + d2)
full_sines += np.sin(np.array([7.362 * d1] * n_offsets).T + d2)
if square:
full_sines[full_sines <= 0] = 0
full_sines[full_sines > 0] = 1
full_sines = full_sines[:, :, None]
return full_sines
n_timesteps = 50
minibatch_size = 4
full_sines = make_sines(10 * n_timesteps, minibatch_size)
all_sines = full_sines[:n_timesteps]
n_full = 10 * n_timesteps
X = all_sines[:-1]
y = all_sines[1:]
n_in = 1
n_hid = 20
n_out = 1
X_sym = tensor.tensor3()
y_sym = tensor.tensor3()
h0 = tensor.fmatrix()
random_state = np.random.RandomState(1999)
X_fork = simple_fork([X_sym], [n_in], n_hid, name="h1",
random_state=random_state)
def step(in_t, h_tm1):
h_t = simple(in_t, h_tm1, n_hid, name="rec", random_state=random_state)
return h_t
h, _ = theano.scan(step,
sequences=[X_fork],
outputs_info=[h0])
y_pred = linear([h], [n_hid], n_out, name="h2", random_state=random_state)
cost = ((y_sym - y_pred) ** 2).sum()
params = list(get_params().values())
params = params
grads = tensor.grad(cost, params)
learning_rate = 0.001
opt = sgd(params, learning_rate)
updates = opt.updates(params, grads)
fit_function = theano.function([X_sym, y_sym, h0], [cost, h], updates=updates)
cost_function = theano.function([X_sym, y_sym, h0], [cost, h])
predict_function = theano.function([X_sym, h0], [y_pred, h])
train_itr = minibatch_iterator([X, y], minibatch_size, axis=1)
valid_itr = minibatch_iterator([X, y], minibatch_size, axis=1)
h_init = np.zeros((minibatch_size, n_hid)).astype("float32")
def train_loop(itr):
X_mb, y_mb = next(itr)
cost, _ = fit_function(X_mb, y_mb, h_init)
return [cost]
def valid_loop(itr):
X_mb, y_mb = next(itr)
cost, _ = cost_function(X_mb, y_mb, h_init)
return [cost]
checkpoint_dict = create_checkpoint_dict(locals())
TL = TrainingLoop(train_loop, train_itr,
valid_loop, valid_itr,
n_epochs=2000,
checkpoint_every_n_epochs=1000,
checkpoint_dict=checkpoint_dict,
skip_minimums=True)
epoch_results = TL.run()
# Run on self generations
n_seed = n_timesteps // 4
X_grow = X[:n_seed]
for i in range(n_timesteps // 4, n_full):
p, _ = predict_function(X_grow, h_init)
# take last prediction only
X_grow = np.concatenate((X_grow, p[-1][None]))
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
f, axarr1 = plt.subplots(minibatch_size, 3)
for i in range(minibatch_size):
# -1 to have the same dims
axarr1[i, 0].plot(full_sines[:-1, i, 0], color="steelblue")
axarr1[i, 1].plot(X_grow[:, i, 0], color="darkred")
axarr1[i, 2].plot(np.abs(X_grow[:-1, i, 0] - full_sines[:-1, i, 0]),
color="darkgreen")
plt.savefig('out.png')
| bsd-3-clause |
DGrady/pandas | asv_bench/benchmarks/io_bench.py | 5 | 6778 | from .pandas_vb_common import *
from pandas import concat, Timestamp, compat
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
import timeit
class frame_to_csv(object):
goal_time = 0.2
def setup(self):
self.df = DataFrame(np.random.randn(3000, 30))
def time_frame_to_csv(self):
self.df.to_csv('__test__.csv')
class frame_to_csv2(object):
goal_time = 0.2
def setup(self):
self.df = DataFrame({'A': range(50000), })
self.df['B'] = (self.df.A + 1.0)
self.df['C'] = (self.df.A + 2.0)
self.df['D'] = (self.df.A + 3.0)
def time_frame_to_csv2(self):
self.df.to_csv('__test__.csv')
class frame_to_csv_date_formatting(object):
goal_time = 0.2
def setup(self):
self.rng = date_range('1/1/2000', periods=1000)
self.data = DataFrame(self.rng, index=self.rng)
def time_frame_to_csv_date_formatting(self):
self.data.to_csv('__test__.csv', date_format='%Y%m%d')
class frame_to_csv_mixed(object):
goal_time = 0.2
def setup(self):
self.df_float = DataFrame(np.random.randn(5000, 5), dtype='float64', columns=self.create_cols('float'))
self.df_int = DataFrame(np.random.randn(5000, 5), dtype='int64', columns=self.create_cols('int'))
self.df_bool = DataFrame(True, index=self.df_float.index, columns=self.create_cols('bool'))
self.df_object = DataFrame('foo', index=self.df_float.index, columns=self.create_cols('object'))
self.df_dt = DataFrame(Timestamp('20010101'), index=self.df_float.index, columns=self.create_cols('date'))
self.df_float.ix[30:500, 1:3] = np.nan
self.df = concat([self.df_float, self.df_int, self.df_bool, self.df_object, self.df_dt], axis=1)
def time_frame_to_csv_mixed(self):
self.df.to_csv('__test__.csv')
def create_cols(self, name):
return [('%s%03d' % (name, i)) for i in range(5)]
class read_csv_infer_datetime_format_custom(object):
goal_time = 0.2
def setup(self):
self.rng = date_range('1/1/2000', periods=1000)
self.data = '\n'.join(self.rng.map((lambda x: x.strftime('%m/%d/%Y %H:%M:%S.%f'))))
def time_read_csv_infer_datetime_format_custom(self):
read_csv(StringIO(self.data), header=None, names=['foo'], parse_dates=['foo'], infer_datetime_format=True)
class read_csv_infer_datetime_format_iso8601(object):
goal_time = 0.2
def setup(self):
self.rng = date_range('1/1/2000', periods=1000)
self.data = '\n'.join(self.rng.map((lambda x: x.strftime('%Y-%m-%d %H:%M:%S'))))
def time_read_csv_infer_datetime_format_iso8601(self):
read_csv(StringIO(self.data), header=None, names=['foo'], parse_dates=['foo'], infer_datetime_format=True)
class read_csv_infer_datetime_format_ymd(object):
goal_time = 0.2
def setup(self):
self.rng = date_range('1/1/2000', periods=1000)
self.data = '\n'.join(self.rng.map((lambda x: x.strftime('%Y%m%d'))))
def time_read_csv_infer_datetime_format_ymd(self):
read_csv(StringIO(self.data), header=None, names=['foo'], parse_dates=['foo'], infer_datetime_format=True)
class read_csv_skiprows(object):
goal_time = 0.2
def setup(self):
self.index = tm.makeStringIndex(20000)
self.df = DataFrame({'float1': randn(20000), 'float2': randn(20000), 'string1': (['foo'] * 20000), 'bool1': ([True] * 20000), 'int1': np.random.randint(0, 200000, size=20000), }, index=self.index)
self.df.to_csv('__test__.csv')
def time_read_csv_skiprows(self):
read_csv('__test__.csv', skiprows=10000)
class read_csv_standard(object):
goal_time = 0.2
def setup(self):
self.index = tm.makeStringIndex(10000)
self.df = DataFrame({'float1': randn(10000), 'float2': randn(10000), 'string1': (['foo'] * 10000), 'bool1': ([True] * 10000), 'int1': np.random.randint(0, 100000, size=10000), }, index=self.index)
self.df.to_csv('__test__.csv')
def time_read_csv_standard(self):
read_csv('__test__.csv')
class read_parse_dates_iso8601(object):
goal_time = 0.2
def setup(self):
self.rng = date_range('1/1/2000', periods=1000)
self.data = '\n'.join(self.rng.map((lambda x: x.strftime('%Y-%m-%d %H:%M:%S'))))
def time_read_parse_dates_iso8601(self):
read_csv(StringIO(self.data), header=None, names=['foo'], parse_dates=['foo'])
class read_uint64_integers(object):
goal_time = 0.2
def setup(self):
self.na_values = [2**63 + 500]
self.arr1 = np.arange(10000).astype('uint64') + 2**63
self.data1 = '\n'.join(map(lambda x: str(x), self.arr1))
self.arr2 = self.arr1.copy().astype(object)
self.arr2[500] = -1
self.data2 = '\n'.join(map(lambda x: str(x), self.arr2))
def time_read_uint64(self):
read_csv(StringIO(self.data1), header=None)
def time_read_uint64_neg_values(self):
read_csv(StringIO(self.data2), header=None)
def time_read_uint64_na_values(self):
read_csv(StringIO(self.data1), header=None, na_values=self.na_values)
class write_csv_standard(object):
goal_time = 0.2
def setup(self):
self.index = tm.makeStringIndex(10000)
self.df = DataFrame({'float1': randn(10000), 'float2': randn(10000), 'string1': (['foo'] * 10000), 'bool1': ([True] * 10000), 'int1': np.random.randint(0, 100000, size=10000), }, index=self.index)
def time_write_csv_standard(self):
self.df.to_csv('__test__.csv')
class read_csv_from_s3(object):
# Make sure that we can read part of a file from S3 without
# needing to download the entire thing. Use the timeit.default_timer
# to measure wall time instead of CPU time -- we want to see
# how long it takes to download the data.
timer = timeit.default_timer
params = ([None, "gzip", "bz2"], ["python", "c"])
param_names = ["compression", "engine"]
def setup(self, compression, engine):
if compression == "bz2" and engine == "c" and compat.PY2:
# The Python 2 C parser can't read bz2 from open files.
raise NotImplementedError
try:
import s3fs
except ImportError:
# Skip these benchmarks if `boto` is not installed.
raise NotImplementedError
self.big_fname = "s3://pandas-test/large_random.csv"
def time_read_nrows(self, compression, engine):
# Read a small number of rows from a huge (100,000 x 50) table.
ext = ""
if compression == "gzip":
ext = ".gz"
elif compression == "bz2":
ext = ".bz2"
pd.read_csv(self.big_fname + ext, nrows=10,
compression=compression, engine=engine)
| bsd-3-clause |
rajegannathan/grasp-lift-eeg-cat-dog-solution-updated | python-packages/mne-python-0.10/mne/viz/circle.py | 13 | 15446 | """Functions to plot on circle as for connectivity
"""
from __future__ import print_function
# Authors: Alexandre Gramfort <[email protected]>
# Denis Engemann <[email protected]>
# Martin Luessi <[email protected]>
#
# License: Simplified BSD
from itertools import cycle
from functools import partial
import numpy as np
from ..externals.six import string_types
from ..fixes import tril_indices, normalize_colors
def circular_layout(node_names, node_order, start_pos=90, start_between=True,
group_boundaries=None, group_sep=10):
"""Create layout arranging nodes on a circle.
Parameters
----------
node_names : list of str
Node names.
node_order : list of str
List with node names defining the order in which the nodes are
arranged. Must have the elements as node_names but the order can be
different. The nodes are arranged clockwise starting at "start_pos"
degrees.
start_pos : float
Angle in degrees that defines where the first node is plotted.
start_between : bool
If True, the layout starts with the position between the nodes. This is
the same as adding "180. / len(node_names)" to start_pos.
group_boundaries : None | array-like
List of of boundaries between groups at which point a "group_sep" will
be inserted. E.g. "[0, len(node_names) / 2]" will create two groups.
group_sep : float
Group separation angle in degrees. See "group_boundaries".
Returns
-------
node_angles : array, shape=(len(node_names,))
Node angles in degrees.
"""
n_nodes = len(node_names)
if len(node_order) != n_nodes:
raise ValueError('node_order has to be the same length as node_names')
if group_boundaries is not None:
boundaries = np.array(group_boundaries, dtype=np.int)
if np.any(boundaries >= n_nodes) or np.any(boundaries < 0):
raise ValueError('"group_boundaries" has to be between 0 and '
'n_nodes - 1.')
if len(boundaries) > 1 and np.any(np.diff(boundaries) <= 0):
raise ValueError('"group_boundaries" must have non-decreasing '
'values.')
n_group_sep = len(group_boundaries)
else:
n_group_sep = 0
boundaries = None
# convert it to a list with indices
node_order = [node_order.index(name) for name in node_names]
node_order = np.array(node_order)
if len(np.unique(node_order)) != n_nodes:
raise ValueError('node_order has repeated entries')
node_sep = (360. - n_group_sep * group_sep) / n_nodes
if start_between:
start_pos += node_sep / 2
if boundaries is not None and boundaries[0] == 0:
# special case when a group separator is at the start
start_pos += group_sep / 2
boundaries = boundaries[1:] if n_group_sep > 1 else None
node_angles = np.ones(n_nodes, dtype=np.float) * node_sep
node_angles[0] = start_pos
if boundaries is not None:
node_angles[boundaries] += group_sep
node_angles = np.cumsum(node_angles)[node_order]
return node_angles
def _plot_connectivity_circle_onpick(event, fig=None, axes=None, indices=None,
n_nodes=0, node_angles=None,
ylim=[9, 10]):
"""Isolates connections around a single node when user left clicks a node.
On right click, resets all connections."""
if event.inaxes != axes:
return
if event.button == 1: # left click
# click must be near node radius
if not ylim[0] <= event.ydata <= ylim[1]:
return
# all angles in range [0, 2*pi]
node_angles = node_angles % (np.pi * 2)
node = np.argmin(np.abs(event.xdata - node_angles))
patches = event.inaxes.patches
for ii, (x, y) in enumerate(zip(indices[0], indices[1])):
patches[ii].set_visible(node in [x, y])
fig.canvas.draw()
elif event.button == 3: # right click
patches = event.inaxes.patches
for ii in range(np.size(indices, axis=1)):
patches[ii].set_visible(True)
fig.canvas.draw()
def plot_connectivity_circle(con, node_names, indices=None, n_lines=None,
node_angles=None, node_width=None,
node_colors=None, facecolor='black',
textcolor='white', node_edgecolor='black',
linewidth=1.5, colormap='hot', vmin=None,
vmax=None, colorbar=True, title=None,
colorbar_size=0.2, colorbar_pos=(-0.3, 0.1),
fontsize_title=12, fontsize_names=8,
fontsize_colorbar=8, padding=6.,
fig=None, subplot=111, interactive=True,
node_linewidth=2., show=True):
"""Visualize connectivity as a circular graph.
Note: This code is based on the circle graph example by Nicolas P. Rougier
http://www.labri.fr/perso/nrougier/coding/.
Parameters
----------
con : array
Connectivity scores. Can be a square matrix, or a 1D array. If a 1D
array is provided, "indices" has to be used to define the connection
indices.
node_names : list of str
Node names. The order corresponds to the order in con.
indices : tuple of arrays | None
Two arrays with indices of connections for which the connections
strenghts are defined in con. Only needed if con is a 1D array.
n_lines : int | None
If not None, only the n_lines strongest connections (strength=abs(con))
are drawn.
node_angles : array, shape=(len(node_names,)) | None
Array with node positions in degrees. If None, the nodes are equally
spaced on the circle. See mne.viz.circular_layout.
node_width : float | None
Width of each node in degrees. If None, the minimum angle between any
two nodes is used as the width.
node_colors : list of tuples | list of str
List with the color to use for each node. If fewer colors than nodes
are provided, the colors will be repeated. Any color supported by
matplotlib can be used, e.g., RGBA tuples, named colors.
facecolor : str
Color to use for background. See matplotlib.colors.
textcolor : str
Color to use for text. See matplotlib.colors.
node_edgecolor : str
Color to use for lines around nodes. See matplotlib.colors.
linewidth : float
Line width to use for connections.
colormap : str
Colormap to use for coloring the connections.
vmin : float | None
Minimum value for colormap. If None, it is determined automatically.
vmax : float | None
Maximum value for colormap. If None, it is determined automatically.
colorbar : bool
Display a colorbar or not.
title : str
The figure title.
colorbar_size : float
Size of the colorbar.
colorbar_pos : 2-tuple
Position of the colorbar.
fontsize_title : int
Font size to use for title.
fontsize_names : int
Font size to use for node names.
fontsize_colorbar : int
Font size to use for colorbar.
padding : float
Space to add around figure to accommodate long labels.
fig : None | instance of matplotlib.pyplot.Figure
The figure to use. If None, a new figure with the specified background
color will be created.
subplot : int | 3-tuple
Location of the subplot when creating figures with multiple plots. E.g.
121 or (1, 2, 1) for 1 row, 2 columns, plot 1. See
matplotlib.pyplot.subplot.
interactive : bool
When enabled, left-click on a node to show only connections to that
node. Right-click shows all connections.
node_linewidth : float
Line with for nodes.
show : bool
Show figure if True.
Returns
-------
fig : instance of matplotlib.pyplot.Figure
The figure handle.
axes : instance of matplotlib.axes.PolarAxesSubplot
The subplot handle.
"""
import matplotlib.pyplot as plt
import matplotlib.path as m_path
import matplotlib.patches as m_patches
n_nodes = len(node_names)
if node_angles is not None:
if len(node_angles) != n_nodes:
raise ValueError('node_angles has to be the same length '
'as node_names')
# convert it to radians
node_angles = node_angles * np.pi / 180
else:
# uniform layout on unit circle
node_angles = np.linspace(0, 2 * np.pi, n_nodes, endpoint=False)
if node_width is None:
# widths correspond to the minimum angle between two nodes
dist_mat = node_angles[None, :] - node_angles[:, None]
dist_mat[np.diag_indices(n_nodes)] = 1e9
node_width = np.min(np.abs(dist_mat))
else:
node_width = node_width * np.pi / 180
if node_colors is not None:
if len(node_colors) < n_nodes:
node_colors = cycle(node_colors)
else:
# assign colors using colormap
node_colors = [plt.cm.spectral(i / float(n_nodes))
for i in range(n_nodes)]
# handle 1D and 2D connectivity information
if con.ndim == 1:
if indices is None:
raise ValueError('indices has to be provided if con.ndim == 1')
elif con.ndim == 2:
if con.shape[0] != n_nodes or con.shape[1] != n_nodes:
raise ValueError('con has to be 1D or a square matrix')
# we use the lower-triangular part
indices = tril_indices(n_nodes, -1)
con = con[indices]
else:
raise ValueError('con has to be 1D or a square matrix')
# get the colormap
if isinstance(colormap, string_types):
colormap = plt.get_cmap(colormap)
# Make figure background the same colors as axes
if fig is None:
fig = plt.figure(figsize=(8, 8), facecolor=facecolor)
# Use a polar axes
if not isinstance(subplot, tuple):
subplot = (subplot,)
axes = plt.subplot(*subplot, polar=True, axisbg=facecolor)
# No ticks, we'll put our own
plt.xticks([])
plt.yticks([])
# Set y axes limit, add additonal space if requested
plt.ylim(0, 10 + padding)
# Remove the black axes border which may obscure the labels
axes.spines['polar'].set_visible(False)
# Draw lines between connected nodes, only draw the strongest connections
if n_lines is not None and len(con) > n_lines:
con_thresh = np.sort(np.abs(con).ravel())[-n_lines]
else:
con_thresh = 0.
# get the connections which we are drawing and sort by connection strength
# this will allow us to draw the strongest connections first
con_abs = np.abs(con)
con_draw_idx = np.where(con_abs >= con_thresh)[0]
con = con[con_draw_idx]
con_abs = con_abs[con_draw_idx]
indices = [ind[con_draw_idx] for ind in indices]
# now sort them
sort_idx = np.argsort(con_abs)
con_abs = con_abs[sort_idx]
con = con[sort_idx]
indices = [ind[sort_idx] for ind in indices]
# Get vmin vmax for color scaling
if vmin is None:
vmin = np.min(con[np.abs(con) >= con_thresh])
if vmax is None:
vmax = np.max(con)
vrange = vmax - vmin
# We want to add some "noise" to the start and end position of the
# edges: We modulate the noise with the number of connections of the
# node and the connection strength, such that the strongest connections
# are closer to the node center
nodes_n_con = np.zeros((n_nodes), dtype=np.int)
for i, j in zip(indices[0], indices[1]):
nodes_n_con[i] += 1
nodes_n_con[j] += 1
# initalize random number generator so plot is reproducible
rng = np.random.mtrand.RandomState(seed=0)
n_con = len(indices[0])
noise_max = 0.25 * node_width
start_noise = rng.uniform(-noise_max, noise_max, n_con)
end_noise = rng.uniform(-noise_max, noise_max, n_con)
nodes_n_con_seen = np.zeros_like(nodes_n_con)
for i, (start, end) in enumerate(zip(indices[0], indices[1])):
nodes_n_con_seen[start] += 1
nodes_n_con_seen[end] += 1
start_noise[i] *= ((nodes_n_con[start] - nodes_n_con_seen[start]) /
float(nodes_n_con[start]))
end_noise[i] *= ((nodes_n_con[end] - nodes_n_con_seen[end]) /
float(nodes_n_con[end]))
# scale connectivity for colormap (vmin<=>0, vmax<=>1)
con_val_scaled = (con - vmin) / vrange
# Finally, we draw the connections
for pos, (i, j) in enumerate(zip(indices[0], indices[1])):
# Start point
t0, r0 = node_angles[i], 10
# End point
t1, r1 = node_angles[j], 10
# Some noise in start and end point
t0 += start_noise[pos]
t1 += end_noise[pos]
verts = [(t0, r0), (t0, 5), (t1, 5), (t1, r1)]
codes = [m_path.Path.MOVETO, m_path.Path.CURVE4, m_path.Path.CURVE4,
m_path.Path.LINETO]
path = m_path.Path(verts, codes)
color = colormap(con_val_scaled[pos])
# Actual line
patch = m_patches.PathPatch(path, fill=False, edgecolor=color,
linewidth=linewidth, alpha=1.)
axes.add_patch(patch)
# Draw ring with colored nodes
height = np.ones(n_nodes) * 1.0
bars = axes.bar(node_angles, height, width=node_width, bottom=9,
edgecolor=node_edgecolor, lw=node_linewidth,
facecolor='.9', align='center')
for bar, color in zip(bars, node_colors):
bar.set_facecolor(color)
# Draw node labels
angles_deg = 180 * node_angles / np.pi
for name, angle_rad, angle_deg in zip(node_names, node_angles, angles_deg):
if angle_deg >= 270:
ha = 'left'
else:
# Flip the label, so text is always upright
angle_deg += 180
ha = 'right'
axes.text(angle_rad, 10.4, name, size=fontsize_names,
rotation=angle_deg, rotation_mode='anchor',
horizontalalignment=ha, verticalalignment='center',
color=textcolor)
if title is not None:
plt.title(title, color=textcolor, fontsize=fontsize_title,
axes=axes)
if colorbar:
norm = normalize_colors(vmin=vmin, vmax=vmax)
sm = plt.cm.ScalarMappable(cmap=colormap, norm=norm)
sm.set_array(np.linspace(vmin, vmax))
cb = plt.colorbar(sm, ax=axes, use_gridspec=False,
shrink=colorbar_size,
anchor=colorbar_pos)
cb_yticks = plt.getp(cb.ax.axes, 'yticklabels')
cb.ax.tick_params(labelsize=fontsize_colorbar)
plt.setp(cb_yticks, color=textcolor)
# Add callback for interaction
if interactive:
callback = partial(_plot_connectivity_circle_onpick, fig=fig,
axes=axes, indices=indices, n_nodes=n_nodes,
node_angles=node_angles)
fig.canvas.mpl_connect('button_press_event', callback)
if show:
plt.show()
return fig, axes
| bsd-3-clause |
AlexCatarino/Lean | PythonToolbox/setup.py | 4 | 1322 | # -*- coding: utf-8 -*-
# QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
# Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect 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.
from setuptools import setup, find_packages
# https://github.com/QuantConnect/Lean/blob/master/LICENSE
with open('../LICENSE') as f:
license = f.read()
with open('README.rst') as f:
readme = f.read()
setup(
name='quantconnect',
version='0.2',
description = 'QuantConnect API',
long_description=readme,
author = 'QuantConnect Python Team',
author_email = '[email protected]',
url='https://www.quantconnect.com/',
license=license,
packages = find_packages(exclude=('tests', 'docs')),
install_requires=['matplotlib', 'pandas', 'requests']
) | apache-2.0 |
USDA-ARS-NWRC/AWSF | awsm/framework/framework.py | 1 | 31367 | import copy
import logging
import os
import sys
from datetime import datetime
import coloredlogs
import pandas as pd
import pytz
from inicheck.config import MasterConfig, UserConfig
from inicheck.output import print_config_report, generate_config
from inicheck.tools import get_user_config, check_config, cast_all_variables
from smrf.utils import utils
import smrf
from spatialnc.topo import topo as mytopo
import smrf.framework.logger as logger
from awsm.convertFiles import convertFiles as cvf
from awsm.data.init_model import modelInit
from awsm.framework import ascii_art
from awsm.interface import interface as smin, smrf_ipysnobal as smrf_ipy, \
ingest_data
from awsm.utils import utilities as awsm_utils
class AWSM():
"""
Args:
configFile (str): path to configuration file.
Returns:
AWSM class instance.
Attributes:
"""
def __init__(self, config):
"""
Initialize the model, read config file, start and end date, and logging
Args:
config: string path to the config file or inicheck UserConfig instance
"""
# read the config file and store
awsm_mcfg = MasterConfig(modules='awsm')
smrf_mcfg = MasterConfig(modules='smrf')
if isinstance(config, str):
if not os.path.isfile(config):
raise Exception('Configuration file does not exist --> {}'
.format(config))
configFile = config
try:
combined_mcfg = MasterConfig(modules=['smrf', 'awsm'])
# Read in the original users config
self.ucfg = get_user_config(configFile, mcfg=combined_mcfg)
self.configFile = configFile
except UnicodeDecodeError as e:
print(e)
raise Exception(('The configuration file is not encoded in '
'UTF-8, please change and retry'))
elif isinstance(config, UserConfig):
self.ucfg = config
configFile = ''
else:
raise Exception(
'Config passed to AWSM is neither file name nor UserConfig instance')
# get the git version
self.gitVersion = awsm_utils.getgitinfo()
# create blank log and error log because logger is not initialized yet
self.tmp_log = []
self.tmp_err = []
self.tmp_warn = []
# Check the user config file for errors and report issues if any
self.tmp_log.append("Checking config file for issues...")
warnings, errors = check_config(self.ucfg)
print_config_report(warnings, errors)
self.config = self.ucfg.cfg
# Exit AWSM if config file has errors
if len(errors) > 0:
print("Errors in the config file. "
"See configuration status report above.")
# sys.exit()
# ################## Decide which modules to run #####################
self.do_smrf = self.config['awsm master']['run_smrf']
#self.do_isnobal = self.config['awsm master']['run_isnobal']
self.model_type = self.config['awsm master']['model_type']
# self.do_smrf_ipysnobal = \
# self.config['awsm master']['run_smrf_ipysnobal']
# self.do_ipysnobal = self.config['awsm master']['run_ipysnobal']
self.do_forecast = False
if 'gridded' in self.config and self.do_smrf:
self.do_forecast = self.config['gridded']['hrrr_forecast_flag']
# WARNING: The value here is inferred in SMRF.data.loadGrid. A
# change here requires a change there
self.n_forecast_hours = 18
# Options for converting files
self.do_make_in = self.config['awsm master']['make_in']
self.do_make_nc = self.config['awsm master']['make_nc']
# do report?
# self.do_report = self.config['awsm master']['do_report']
self.snowav_config = self.config['awsm master']['snowav_config']
# options for masking isnobal
self.mask_isnobal = self.config['awsm master']['mask_isnobal']
# prompt for making directories
self.prompt_dirs = self.config['awsm master']['prompt_dirs']
# store smrf version if running smrf
self.smrf_version = smrf.__version__
# ################ Time information ##################
self.start_date = pd.to_datetime(self.config['time']['start_date'])
self.end_date = pd.to_datetime(self.config['time']['end_date'])
self.time_step = self.config['time']['time_step']
self.tmz = self.config['time']['time_zone']
self.tzinfo = pytz.timezone(self.config['time']['time_zone'])
# date to use for finding wy
tmp_date = self.start_date.replace(tzinfo=self.tzinfo)
tmp_end_date = self.end_date.replace(tzinfo=self.tzinfo)
# find water year hour of start and end date
self.start_wyhr = int(utils.water_day(tmp_date)[0]*24)
self.end_wyhr = int(utils.water_day(tmp_end_date)[0]*24)
# find start of water year
tmpwy = utils.water_day(tmp_date)[1] - 1
self.wy_start = pd.to_datetime('{:d}-10-01'.format(tmpwy))
# ################ Store some paths from config file ##################
# path to the base drive (i.e. /data/blizzard)
if self.config['paths']['path_dr'] is not None:
self.path_dr = os.path.abspath(self.config['paths']['path_dr'])
else:
print('No base path to drive given. Exiting now!')
sys.exit()
# name of your basin (i.e. Tuolumne)
self.basin = self.config['paths']['basin']
# water year of run
self.wy = utils.water_day(tmp_date)[1]
# if the run is operational or not
self.isops = self.config['paths']['isops']
# name of project if not an operational run
self.proj = self.config['paths']['proj']
# check for project description
self.desc = self.config['paths']['desc']
# find style for folder date stamp
self.folder_date_style = self.config['paths']['folder_date_style']
# setting to output in seperate daily folders
self.daily_folders = self.config['awsm system']['daily_folders']
if self.daily_folders and not self.run_smrf_ipysnobal:
raise ValueError('Cannot run daily_folders with anything other'
' than run_smrf_ipysnobal')
if self.do_forecast:
self.tmp_log.append('Forecasting set to True')
# self.fp_forecastdata = self.config['gridded']['wrf_file']
# if self.fp_forecastdata is None:
# self.tmp_err.append('Forecast set to true, '
# 'but no grid file given')
# print("Errors in the config file. See configuration "
# "status report above.")
# print(self.tmp_err)
# sys.exit()
if self.config['system']['threading']:
# Can't run threaded smrf if running forecast_data
self.tmp_err.append('Cannot run SMRF threaded with'
' gridded input data')
print(self.tmp_err)
sys.exit()
# Time step mass thresholds for iSnobal
self.mass_thresh = []
self.mass_thresh.append(self.config['grid']['thresh_normal'])
self.mass_thresh.append(self.config['grid']['thresh_medium'])
self.mass_thresh.append(self.config['grid']['thresh_small'])
# threads for running iSnobal
self.ithreads = self.config['awsm system']['ithreads']
# how often to output form iSnobal
self.output_freq = self.config['awsm system']['output_frequency']
# number of timesteps to run if ou don't want to run the whole thing
self.run_for_nsteps = self.config['awsm system']['run_for_nsteps']
# pysnobal output variables
self.pysnobal_output_vars = self.config['awsm system']['variables']
self.pysnobal_output_vars = [wrd.lower()
for wrd in self.pysnobal_output_vars]
# snow and emname
self.snow_name = self.config['awsm system']['snow_name']
self.em_name = self.config['awsm system']['em_name']
# options for restarting iSnobal
self.restart_crash = False
if self.config['isnobal restart']['restart_crash']:
self.restart_crash = True
# self.new_init = self.config['isnobal restart']['new_init']
self.depth_thresh = self.config['isnobal restart']['depth_thresh']
self.restart_hr = \
int(self.config['isnobal restart']['wyh_restart_output'])
self.restart_folder = self.config['isnobal restart']['output_folders']
# iSnobal active layer
self.active_layer = self.config['grid']['active_layer']
# if we are going to run ipysnobal with smrf
if self.model_type in ['ipysnobal', 'smrf_ipysnobal']:
self.ipy_threads = self.ithreads
self.ipy_init_type = \
self.config['files']['init_type']
self.forcing_data_type = \
self.config['ipysnobal']['forcing_data_type']
# parameters needed for restart procedure
self.restart_run = False
if self.config['isnobal restart']['restart_crash']:
self.restart_run = True
# find restart hour datetime
reset_offset = pd.to_timedelta(self.restart_hr, unit='h')
# set a new start date for this run
self.restart_date = self.wy_start + reset_offset
self.tmp_log.append('Restart date is {}'.format(self.start_date))
# read in update depth parameters
self.update_depth = False
if 'update depth' in self.config:
self.update_depth = self.config['update depth']['update']
if self.update_depth:
self.update_file = self.config['update depth']['update_file']
self.update_buffer = self.config['update depth']['buffer']
self.flight_numbers = self.config['update depth']['flight_numbers']
# if flights to use is not list, make it a list
if self.flight_numbers is not None:
if not isinstance(self.flight_numbers, list):
self.flight_numbers = [self.flight_numbers]
# list of sections releated to AWSM
# These will be removed for smrf config
self.sec_awsm = awsm_mcfg.cfg.keys()
self.sec_smrf = smrf_mcfg.cfg.keys()
# Make rigid directory structure
self.mk_directories()
# ################ Topo data for iSnobal ##################
# get topo stats
self.csys = self.config['grid']['csys'].upper()
self.nbits = int(self.config['grid']['nbits'])
self.soil_temp = self.config['soil_temp']['temp']
# get topo class
self.topo = mytopo(self.config['topo'], self.mask_isnobal,
self.model_type, self.csys, self.pathdd)
# ################ Generate config backup ##################
# if self.config['output']['input_backup']:
# set location for backup and output backup of awsm sections
config_backup_location = \
os.path.join(self.pathdd, 'awsm_config_backup.ini')
generate_config(self.ucfg, config_backup_location)
# create log now that directory structure is done
self.createLog()
# if we have a model, initialize it
if self.model_type is not None:
self.myinit = modelInit(self._logger, self.config, self.topo,
self.start_wyhr, self.pathro, self.pathrr,
self.pathinit, self.wy_start)
def createLog(self):
'''
Now that the directory structure is done, create log file and print out
saved logging statements.
'''
level_styles = {'info': {'color': 'white'},
'notice': {'color': 'magenta'},
'verbose': {'color': 'blue'},
'success': {'color': 'green', 'bold': True},
'spam': {'color': 'green', 'faint': True},
'critical': {'color': 'red', 'bold': True},
'error': {'color': 'red'},
'debug': {'color': 'green'},
'warning': {'color': 'yellow'}}
field_styles = {'hostname': {'color': 'magenta'},
'programname': {'color': 'cyan'},
'name': {'color': 'white'},
'levelname': {'color': 'white', 'bold': True},
'asctime': {'color': 'green'}}
# start logging
loglevel = self.config['awsm system']['log_level'].upper()
numeric_level = getattr(logging, loglevel, None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % loglevel)
# setup the logging
logfile = None
if self.config['awsm system']['log_to_file']:
if self.config['isnobal restart']['restart_crash']:
logfile = \
os.path.join(self.pathll,
'log_restart_{}.out'.format(self.restart_hr))
elif self.do_forecast:
logfile = \
os.path.join(self.pathll,
'log_forecast_'
'{}.out'.format(self.folder_date_stamp))
else:
logfile = \
os.path.join(self.pathll,
'log_{}.out'.format(self.folder_date_stamp))
# let user know
print('Logging to file: {}'.format(logfile))
self.config['awsm system']['log_file'] = logfile
logger.SMRFLogger(self.config['awsm system'])
self._logger = logging.getLogger(__name__)
self._logger.info(ascii_art.MOUNTAIN)
self._logger.info(ascii_art.TITLE)
# dump saved logs
if len(self.tmp_log) > 0:
for l in self.tmp_log:
self._logger.info(l)
if len(self.tmp_warn) > 0:
for l in self.tmp_warn:
self._logger.warning(l)
if len(self.tmp_err) > 0:
for l in self.tmp_err:
self._logger.error(l)
def runSmrf(self):
"""
Run smrf. Calls :mod: `awsm.interface.interface.smrfMEAS`
"""
# modify config and run smrf
smin.smrfMEAS(self)
def nc2ipw(self, runtype):
"""
Convert ipw smrf output to isnobal inputs
"""
cvf.nc2ipw_mea(self, runtype)
def ipw2nc(self, runtype):
"""
Convert ipw output to netcdf files. Calls
:mod: `awsm.convertFiles.convertFiles.ipw2nc_mea`
"""
cvf.ipw2nc_mea(self, runtype)
def run_isnobal(self, offset=None):
"""
Run isnobal. Calls :mod: `awsm.interface.interface.run_isnobal`
"""
smin.run_isnobal(self, offset=offset)
def run_isnobal_update(self):
"""
Run iSnobal with update procedure
"""
# initialize updater
updater = ingest_data.StateUpdater(self)
# run iSnobal with updates
updater.run_update_procedure_isnobal(self)
def run_smrf_ipysnobal(self):
"""
Run smrf and pass inputs to ipysnobal in memory.
Calls :mod: `awsm.interface.smrf_ipysnobal.run_smrf_ipysnobal`
"""
smrf_ipy.run_smrf_ipysnobal(self)
def run_awsm_daily(self):
"""
This function runs :mod: `awsm.interface.smrf_ipysnobal.run_smrf_ipysnobal`
on an hourly output from Pysnobal, outputting to daily folders, similar
to the HRRR froecast.
"""
smin.run_awsm_daily(self)
def run_ipysnobal(self):
"""
Run PySnobal from previously run smrf forcing data
Calls :mod: `awsm.interface.smrf_ipysnobal.run_ipysnobal`
"""
smrf_ipy.run_ipysnobal(self)
def mk_directories(self):
"""
Create all needed directories starting from the working drive
"""
# rigid directory work
self.tmp_log.append('AWSM creating directories')
# string to append to folders indicatiing run start and end
if self.folder_date_style == 'wyhr':
self.folder_date_stamp = '{:04d}_{:04d}'.format(self.start_wyhr,
self.end_wyhr)
elif self.folder_date_style == 'day':
self.folder_date_stamp = \
'{}'.format(self.start_date.strftime("%Y%m%d"))
elif self.folder_date_style == 'start_end':
self.folder_date_stamp = \
'{}_{}'.format(self.start_date.strftime("%Y%m%d"),
self.end_date.strftime("%Y%m%d"))
# make basin path
self.path_ba = os.path.join(self.path_dr, self.basin)
# check if ops or dev
if self.isops:
opsdev = 'ops'
else:
opsdev = 'devel'
# assign paths accordinly
self.path_od = os.path.join(self.path_ba, opsdev)
self.path_wy = os.path.join(self.path_od, 'wy{}'.format(self.wy))
self.path_wy = os.path.join(self.path_wy, self.proj)
# specific data folder conatining
self.pathd = os.path.join(self.path_wy, 'data')
self.pathr = os.path.join(self.path_wy, 'runs')
# log folders
self.pathlog = os.path.join(self.path_wy, 'logs')
self.pathll = os.path.join(self.pathlog,
'log{}'.format(self.folder_date_stamp))
# name of temporary smrf file to write out
self.smrfini = os.path.join(self.path_wy, 'tmp_smrf_config.ini')
self.forecastini = os.path.join(self.path_wy,
'tmp_smrf_forecast_config.ini')
# if not self.do_forecast:
# assign path names for isnobal, path_names_att will be used
# to create necessary directories
path_names_att = ['pathdd', 'pathrr', 'pathi',
'pathinit', 'pathro', 'paths', 'path_ppt']
self.pathdd = \
os.path.join(self.pathd,
'data{}'.format(self.folder_date_stamp))
self.pathrr = \
os.path.join(self.pathr,
'run{}'.format(self.folder_date_stamp))
self.pathi = os.path.join(self.pathdd, 'input/')
self.pathinit = os.path.join(self.pathdd, 'init/')
self.pathro = os.path.join(self.pathrr, 'output/')
self.paths = os.path.join(self.pathdd, 'smrfOutputs')
self.ppt_desc = \
os.path.join(self.pathdd,
'ppt_desc{}.txt'.format(self.folder_date_stamp))
self.path_ppt = os.path.join(self.pathdd, 'ppt_4b')
# used to check if data direcotry exists
check_if_data = not os.path.exists(self.pathdd)
# else:
# path_names_att = ['pathdd', 'pathrr', 'pathi',
# 'pathinit', 'pathro', 'paths', 'path_ppt']
# self.pathdd = \
# os.path.join(self.pathd,
# 'forecast{}'.format(self.folder_date_stamp))
# self.pathrr = \
# os.path.join(self.pathr,
# 'forecast{}'.format(self.folder_date_stamp))
# self.pathi = os.path.join(self.pathdd, 'input/')
# self.pathinit = os.path.join(self.pathdd, 'init/')
# self.pathro = os.path.join(self.pathrr, 'output/')
# self.paths = os.path.join(self.pathdd, 'smrfOutputs')
# self.ppt_desc = \
# os.path.join(self.pathdd,
# 'ppt_desc{}.txt'.format(self.folder_date_stamp))
# self.path_ppt = os.path.join(self.pathdd, 'ppt_4b')
#
# # used to check if data direcotry exists
# check_if_data = not os.path.exists(self.pathdd)
# add log path to create directory
path_names_att.append('pathll')
# always check paths
check_if_data = True
# Only start if your drive exists
if os.path.exists(self.path_dr):
# If the specific path to your WY does not exist,
# create it and following directories/
# If the working path specified in the config file does not exist
if not os.path.exists(self.path_wy):
y_n = 'a' # set a funny value to y_n
# while it is not y or n (for yes or no)
while y_n not in ['y', 'n']:
if self.prompt_dirs:
y_n = input('Directory %s does not exist. Create base '
'directory and all subdirectories? '
'(y n): ' % self.path_wy)
else:
y_n = 'y'
if y_n == 'n':
self.tmp_err.append('Please fix the base directory'
' (path_wy) in your config file.')
print(self.tmp_err)
sys.exit()
elif y_n == 'y':
self.make_rigid_directories(path_names_att)
# If WY exists, but not this exact run for the dates, create it
elif check_if_data:
y_n = 'a'
while y_n not in ['y', 'n']:
if self.prompt_dirs:
y_n = input('Directory %s does not exist. Create base '
'directory and all subdirectories? '
'(y n): ' % self.pathdd)
else:
y_n = 'y'
if y_n == 'n':
self.tmp_err.append('Please fix the base directory'
' (path_wy) in your config file.')
print(self.tmp_err)
sys.exit()
elif y_n == 'y':
self.make_rigid_directories(path_names_att)
else:
self.tmp_warn.append('Directory structure leading to '
'{} already exists.'.format(self.pathdd))
# make sure runs exists
if not os.path.exists(os.path.join(self.path_wy, 'runs/')):
os.makedirs(os.path.join(self.path_wy, 'runs/'))
# if we're not running forecast, make sure path to outputs exists
if not os.path.exists(self.pathro):
os.makedirs(self.pathro)
# find where to write file
fp_desc = os.path.join(self.path_wy, 'projectDescription.txt')
if not os.path.isfile(fp_desc):
# look for description or prompt for one
if self.desc is not None:
pass
else:
self.desc = input('\nNo description for project. '
'Enter one now, but do not use '
'any punctuation:\n')
f = open(fp_desc, 'w')
f.write(self.desc)
f.close()
else:
self.tmp_log.append('Description file already exists\n')
else:
self.tmp_err.append('Base directory did not exist, '
'not safe to continue. Make sure base '
'directory exists before running.')
print(self.tmp_err)
sys.exit()
def make_rigid_directories(self, path_name):
"""
Creates rigid directory structure from list of relative bases and
extensions from the base
"""
# loop through lists
for idp, pn in enumerate(path_name):
# get attribute of path
path = getattr(self, pn)
if not os.path.exists(path):
os.makedirs(path)
else:
self.tmp_log.append('Directory --{}-- exists, not creating.\n')
def run_report(self):
try:
import snowav
self._logger.info('AWSM finished run, starting report')
snowav.framework.framework.snowav(config_file=self.snowav_config)
except ModuleNotFoundError:
print('Library snowav not installed - skip reporting')
def __enter__(self):
self.start_time = datetime.now()
return self
def __exit__(self, exc_type, exc_value, traceback):
"""
Provide some logging info about when AWSM was closed
"""
self._logger.info(
'AWSM finished in: {}'.format(datetime.now() - self.start_time)
)
self._logger.info('AWSM closed --> %s' % datetime.now())
def run_awsm_daily_ops(config_file):
"""
Run each day seperately. Calls run_awsm
"""
# define some formats
fmt_day = '%Y%m%d'
fmt_cfg = '%Y-%m-%d %H:%M'
add_day = pd.to_timedelta(24, unit='h')
# get config instance
config = get_user_config(config_file,
modules=['smrf', 'awsm'])
# copy the config and get total start and end
# config = deepcopy(base_config)
# set naming style
config.raw_cfg['paths']['folder_date_style'] = 'day'
config.apply_recipes()
config = cast_all_variables(config, config.mcfg)
# get the water year
cfg_start_date = pd.to_datetime(config.cfg['time']['start_date'])
tzinfo = pytz.timezone(config.cfg['time']['time_zone'])
wy = utils.water_day(cfg_start_date.replace(tzinfo=tzinfo))[1]
# find the model start depending on restart
if config.cfg['isnobal restart']['restart_crash']:
offset_wyhr = int(config.cfg['isnobal restart']['wyh_restart_output'])
wy_start = pd.to_datetime('{:d}-10-01'.format(wy - 1))
model_start = wy_start + pd.to_timedelta(offset_wyhr, unit='h')
else:
model_start = config.cfg['time']['start_date']
model_end = config.cfg['time']['end_date']
isops = config.cfg['paths']['isops']
if isops:
devops = 'ops'
else:
devops = 'devel'
# find output location for previous output
paths = config.cfg['paths']
prev_out_base = os.path.join(paths['path_dr'],
paths['basin'],
devops,
'wy{}'.format(wy),
paths['proj'],
'runs')
prev_data_base = os.path.join(paths['path_dr'],
paths['basin'],
devops,
'wy{}'.format(wy),
paths['proj'],
'data')
# find day of start and end
start_day = pd.to_datetime(model_start.strftime(fmt_day))
end_day = pd.to_datetime(model_end.strftime(fmt_day))
# find total range of run
ndays = int((end_day-start_day).days) + 1
date_list = [start_day +
pd.to_timedelta(x, unit='D') for x in range(0, ndays)]
# loop through daily runs and run awsm
for idd, sd in enumerate(date_list):
new_config = copy.deepcopy(config)
if idd > 0:
new_config.raw_cfg['isnobal restart']['restart_crash'] = False
new_config.raw_cfg['grid']['thresh_normal'] = 60
new_config.raw_cfg['grid']['thresh_medium'] = 10
new_config.raw_cfg['grid']['thresh_small'] = 1
# get the end of the day
ed = sd + add_day
# make sure we're in the model date range
if sd < model_start:
sd = model_start
if ed > model_end:
ed = model_end
# set the start and end dates
new_config.raw_cfg['time']['start_date'] = sd.strftime(fmt_cfg)
new_config.raw_cfg['time']['end_date'] = ed.strftime(fmt_cfg)
# reset the initialization
if idd > 0:
# find previous output file
prev_day = sd - pd.to_timedelta(1, unit='D')
prev_out = os.path.join(prev_out_base,
'run{}'.format(prev_day.strftime(fmt_day)),
'snow.nc')
# reset if running the model
if new_config.cfg['awsm master']['model_type'] is not None:
new_config.raw_cfg['files']['init_type'] = 'netcdf_out'
new_config.raw_cfg['files']['init_file'] = prev_out
# if we have a previous storm day file, use it
prev_storm = os.path.join(prev_data_base,
'data{}'.format(
prev_day.strftime(fmt_day)),
'smrfOutputs', 'storm_days.nc')
if os.path.isfile(prev_storm):
new_config.raw_cfg['precip']['storm_days_restart'] = prev_storm
# apply recipes with new settings
new_config.apply_recipes()
new_config = cast_all_variables(new_config, new_config.mcfg)
# run awsm for the day
run_awsm(new_config)
def run_awsm(config):
"""
Function that runs awsm how it should be operate for full runs.
Args:
config: string path to the config file or inicheck UserConfig instance
"""
with AWSM(config) as a:
if a.do_forecast:
runtype = 'forecast'
else:
runtype = 'smrf'
if not a.config['isnobal restart']['restart_crash']:
# distribute data by running smrf
if a.do_smrf:
a.runSmrf()
# convert smrf output to ipw for iSnobal
if a.do_make_in:
a.nc2ipw(runtype)
if a.model_type == 'isnobal':
# run iSnobal
if a.update_depth:
a.run_isnobal_update()
else:
a.run_isnobal()
elif a.model_type == 'ipysnobal':
# run iPySnobal
a.run_ipysnobal()
# convert ipw back to netcdf for processing
if a.do_make_nc:
a.ipw2nc(runtype)
# if restart
else:
if a.model_type == 'isnobal':
# restart iSnobal from crash
if a.update_depth:
a.run_isnobal_update()
else:
a.run_isnobal()
# convert ipw back to netcdf for processing
elif a.model_type == 'ipysnobal':
# run iPySnobal
a.run_ipysnobal()
if a.do_make_nc:
a.ipw2nc(runtype)
# Run iPySnobal from SMRF in memory
if a.model_type == 'smrf_ipysnobal':
if a.daily_folders:
a.run_awsm_daily()
else:
a.run_smrf_ipysnobal()
# create report
if a.snowav_config is not None:
a.run_report()
| gpl-3.0 |
hariseldon99/archives | eth_question/scripts/vec_binplot.py | 1 | 1126 | #!/usr/bin/python
"""
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Rigol Lattice: postprocessing of Petsc Vector data
* Copyright (c) 2013 Analabha Roy ([email protected])
*
* This is free software: you can redistribute it and/or modify it under the
* terms of version 3 of the GNU Lesser General Public License as published by
* the Free Software Foundation.
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
"""
"""
Python program to
read a petsc binary vector using numpy
and plot by index
Usage: vec_binplot.py <PetSc binary vector>
"""
import numpy as np
import matplotlib.pyplot as plt
import sys,os
sys.path.append(os.path.join(os.environ['PETSC_DIR'],'bin','pythonscripts'))
import PetscBinaryIO
if __name__ == '__main__':
petsc = PetscBinaryIO.PetscBinaryIO()
vec = petsc.readBinaryFile(sys.argv[1])
vec = list(vec)[0]
x = range(len(vec))
#np.ndarray.sort(vec)
plt.plot(x,vec)
plt.xlim((0,x[-1]))
plt.show()
# Uncomment for remote systems
# plt.savefig('vec.svg')
# print "Output in svg file"
| gpl-2.0 |
IntelLabs/hpat | examples/series/rolling/series_rolling_mean.py | 1 | 1813 | # *****************************************************************************
# Copyright (c) 2020, Intel Corporation All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# *****************************************************************************
import pandas as pd
from numba import njit
@njit
def series_rolling_mean():
series = pd.Series([4, 3, 5, 2, 6]) # Series of 4, 3, 5, 2, 6
out_series = series.rolling(3).mean()
return out_series # Expect series of NaN, NaN, 4.000000, 3.333333, 4.333333
print(series_rolling_mean())
| bsd-2-clause |
petosegan/scikit-learn | benchmarks/bench_plot_lasso_path.py | 301 | 4003 | """Benchmarks of Lasso regularization path computation using Lars and CD
The input data is mostly low rank but is a fat infinite tail.
"""
from __future__ import print_function
from collections import defaultdict
import gc
import sys
from time import time
import numpy as np
from sklearn.linear_model import lars_path
from sklearn.linear_model import lasso_path
from sklearn.datasets.samples_generator import make_regression
def compute_bench(samples_range, features_range):
it = 0
results = defaultdict(lambda: [])
max_it = len(samples_range) * len(features_range)
for n_samples in samples_range:
for n_features in features_range:
it += 1
print('====================')
print('Iteration %03d of %03d' % (it, max_it))
print('====================')
dataset_kwargs = {
'n_samples': n_samples,
'n_features': n_features,
'n_informative': n_features / 10,
'effective_rank': min(n_samples, n_features) / 10,
#'effective_rank': None,
'bias': 0.0,
}
print("n_samples: %d" % n_samples)
print("n_features: %d" % n_features)
X, y = make_regression(**dataset_kwargs)
gc.collect()
print("benchmarking lars_path (with Gram):", end='')
sys.stdout.flush()
tstart = time()
G = np.dot(X.T, X) # precomputed Gram matrix
Xy = np.dot(X.T, y)
lars_path(X, y, Xy=Xy, Gram=G, method='lasso')
delta = time() - tstart
print("%0.3fs" % delta)
results['lars_path (with Gram)'].append(delta)
gc.collect()
print("benchmarking lars_path (without Gram):", end='')
sys.stdout.flush()
tstart = time()
lars_path(X, y, method='lasso')
delta = time() - tstart
print("%0.3fs" % delta)
results['lars_path (without Gram)'].append(delta)
gc.collect()
print("benchmarking lasso_path (with Gram):", end='')
sys.stdout.flush()
tstart = time()
lasso_path(X, y, precompute=True)
delta = time() - tstart
print("%0.3fs" % delta)
results['lasso_path (with Gram)'].append(delta)
gc.collect()
print("benchmarking lasso_path (without Gram):", end='')
sys.stdout.flush()
tstart = time()
lasso_path(X, y, precompute=False)
delta = time() - tstart
print("%0.3fs" % delta)
results['lasso_path (without Gram)'].append(delta)
return results
if __name__ == '__main__':
from mpl_toolkits.mplot3d import axes3d # register the 3d projection
import matplotlib.pyplot as plt
samples_range = np.linspace(10, 2000, 5).astype(np.int)
features_range = np.linspace(10, 2000, 5).astype(np.int)
results = compute_bench(samples_range, features_range)
max_time = max(max(t) for t in results.values())
fig = plt.figure('scikit-learn Lasso path benchmark results')
i = 1
for c, (label, timings) in zip('bcry', sorted(results.items())):
ax = fig.add_subplot(2, 2, i, projection='3d')
X, Y = np.meshgrid(samples_range, features_range)
Z = np.asarray(timings).reshape(samples_range.shape[0],
features_range.shape[0])
# plot the actual surface
ax.plot_surface(X, Y, Z.T, cstride=1, rstride=1, color=c, alpha=0.8)
# dummy point plot to stick the legend to since surface plot do not
# support legends (yet?)
#ax.plot([1], [1], [1], color=c, label=label)
ax.set_xlabel('n_samples')
ax.set_ylabel('n_features')
ax.set_zlabel('Time (s)')
ax.set_zlim3d(0.0, max_time * 1.1)
ax.set_title(label)
#ax.legend()
i += 1
plt.show()
| bsd-3-clause |
I2Cvb/data_balancing | pipeline/feature-classification/classification_melanoma_random_forest.py | 1 | 7763 | #title :classiciation_imbalanced_study.py
#description :This will create a header for a python script.
#author :Guillaume Lemaitre, Mojdeh Rastgoo
#date :2016/01/19
#version :0.1
#notes :
#python_version :2.7.6
#==============================================================================
# Import the needed libraries
# Numpy library
import numpy as np
import pandas as pd
import h5py
# Joblib library
### Module to performed parallel processing
from joblib import Parallel, delayed
### Module to performed parallel processing
import multiprocessing
# OS library
import os
from os.path import join, isdir, isfile
# sys library
import sys
# Scikit-learn library
from sklearn.datasets import make_classification
from sklearn.cross_validation import KFold
from sklearn.cross_validation import StratifiedKFold
from sklearn.preprocessing import MinMaxScaler
from protoclass.classification.classification import Classify
# Initialization to the data paths
dataPath = sys.argv[1]
path_to_save = sys.argv[2]
#fread = pd.read_csv(dataPath.__add__('feature.csv'))
fread = pd.read_csv(join(dataPath, 'feature.csv'))
FeatureLists = fread.values
FeatureLists = FeatureLists[:,0]
#f= h5py.File(dataPath.__add__('PH2_Train_Test_80_20.mat'), 'r')
f = h5py.File(join(dataPath, 'PH2_Train_Test_80_20.mat'), 'r')
#CVIdx = sio.loadmat(datapath.__add__('TrainTestIndex_117_39_80.mat'))
trainIdx = np.asmatrix(f.get('trainingIdx'))
trainIdx = trainIdx.T
trainIdx = trainIdx - 1.
testIdx = np.asmatrix(f.get('testingIdx'))
testIdx = testIdx.T
testIdx = testIdx - 1.
Labels= np.asmatrix(f.get('BinaryLabels'))
Labels = Labels.T
ntree = 100;
config = [{'classifier_str' : 'random-forest', 'n_estimators' : 100},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'random-over-sampling'},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'smote', 'kind_smote' : 'regular'},
#{'classifier_str' : 'random-forest', 'n_estimators' : 100,
#'balancing_criterion' : 'smote', 'kind_smote' : 'borderline1'},
#{'classifier_str' : 'random-forest', 'n_estimators' : 100,
#'balancing_criterion' : 'smote', 'kind_smote' : 'borderline2'},
#{'classifier_str' : 'random-forest', 'n_estimators' : 100,
#'balancing_criterion' : 'smote', 'kind_smote' : 'svm'},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'random-under-sampling', 'replacement' : True},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'tomek_links'},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'clustering'},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'nearmiss', 'version_nearmiss' : 1, 'size_ngh': 3},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'nearmiss', 'version_nearmiss' : 2, 'size_ngh': 3},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'nearmiss', 'version_nearmiss' : 3, 'size_ngh': 3, 'ver3_samp_ngh' : 3},
#{'classifier_str' : 'random-forest', 'n_estimators' : 100,
#'balancing_criterion' : 'cnn', 'size_ngh' : 3, 'n_seeds_S' :1},
#{'classifier_str' : 'random-forest', 'n_estimators' : 100,
#'balancing_criterion' : 'one-sided-selection', 'size_ngh' : 1, 'n_seeds_S' :1},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'ncr', 'size_ngh' : 3},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'easy-ensemble', 'n_subsets' : 10},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'balance-cascade', 'n_max_subset' : 100,
'balancing_classifier' : 'knn', 'bootstrap' : True},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'smote-enn', 'size_ngh' : 3},
{'classifier_str' : 'random-forest', 'n_estimators' : 100,
'balancing_criterion' : 'smote-tomek'}]
FeaturesIdx = np.array([[1,0,0,0,0,0], [0,1,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1],\
[1,1,0,0,0,0], [1,0,1,0,0,0], [1,0,0,1,0,0], [0,1,1,0,0,0], [0,1,0,1,0,0], [0,0,1,1,0,0],\
[0,0,0,0,1,1], [1,1,1,1,0,0], [1,0,0,0,1,1], [0,1,0,0,1,1], [0,0,1,0,1,1], [0,0,0,1,1,1],\
[1,1,0,0,1,1], [1,0,1,0,1,1], [1,0,0,1,1,1], [0,1,1,0,1,1], [0,1,0,1,1,1], [0,0,1,1,1,1]])
#[0,1,0,0],[0,0,1,0],[0,0,0,1] , [0,0,1,1], [1,1,0,0],[1,0,1,1],[0,1,1,1],[1,1,1,1]])
for I in range (0, FeaturesIdx.shape[0]):
NonzeroIdx = np.ravel(np.nonzero(FeaturesIdx[I]))
FVcombined = np.empty(shape = [193, 0])
for PIdx in range (0, NonzeroIdx.shape[0]):
f= h5py.File(join(dataPath,FeatureLists[NonzeroIdx[PIdx]]), 'r')
#f = sio.loadmat(join(featurePath, FeatureLists[NonzeroIdx[PIdx]]))
FV =np.asmatrix(f.get('FV'))
FV =FV.T
FVcombined = np.append(FVcombined, FV, axis = 1)
del FV
FV = FVcombined
rocs = []
gt_labels = []
pred_labels = []
pred_probs = []
# Apply the classification for each fold
n_jobs = -5
for CV in range (0, trainIdx.shape[1]):
print 'Iteration #{}'.format(CV)
# Extract the data
### Training
train_data = FV[np.ravel(trainIdx[:,CV].astype(int)), :]
train_label = np.ravel(Labels[np.ravel(trainIdx[:,CV].astype(int))])
### Testing
test_data = FV[np.ravel(testIdx[:,CV].astype(int)), :]
test_label = np.ravel(Labels[np.ravel(testIdx[:,CV].astype(int))])
config_roc = []
config_pred_label = []
config_pred_prob = []
config_gt_label = []
for c in config:
print c
pred_label, pred_prob, roc = Classify(train_data, train_label, test_data, test_label, gs_n_jobs=n_jobs, **c)
config_roc.append(roc)
config_pred_label.append(pred_label)
config_pred_prob.append(pred_prob)
config_gt_label.append(test_label)
rocs.append(config_roc)
pred_labels.append(config_pred_label)
pred_probs.append(config_pred_prob)
gt_labels.append(config_gt_label)
# Convert the data to store to numpy data
rocs = np.array(rocs)
pred_labels = np.array(pred_labels)
pred_probs = np.array(pred_probs)
gt_labels = np.array(gt_labels)
# Reshape the array to have the first index corresponding to the
# configuration, the second index to the iteration of the k-fold
# and the last index to the data themselve.
rocs = np.swapaxes(rocs, 0, 1)
pred_labels = np.swapaxes(pred_labels, 0, 1)
pred_probs = np.swapaxes(pred_probs, 0, 1)
gt_labels = np.swapaxes(gt_labels, 0, 1)
# Save the results somewhere
if not os.path.exists(path_to_save):
os.makedirs(path_to_save)
from os.path import basename
saving_filename = 'melanoma_imbalanced_80_20_' + str(ntree) + '_' + str(I)
saving_path = join(path_to_save, saving_filename)
np.savez(saving_path, gt_labels=gt_labels, pred_labels=pred_labels, pred_probs=pred_probs, rocs=rocs)
tosave={}
tosave['rocs'] = rocs
tosave['pred_labels'] = pred_labels
tosave['pred_probs'] = pred_probs
tosave['gt_labels'] = gt_labels
saving_path = join(path_to_save, saving_filename)
from scipy.io import savemat
savemat(saving_path, tosave)
| mit |
AustereCuriosity/astropy | astropy/table/tests/test_table.py | 1 | 68562 | # -*- coding: utf-8 -*-
# Licensed under a 3-clause BSD style license - see LICENSE.rst
# TEST_UNICODE_LITERALS
import copy
import gc
import sys
from collections import OrderedDict
import numpy as np
from numpy.testing import assert_allclose
from ...extern import six
from ...io import fits
from ...tests.helper import (pytest, assert_follows_unicode_guidelines,
ignore_warnings, catch_warnings)
from ...utils.data import get_pkg_data_filename
from ... import table
from ... import units as u
from .conftest import MaskedTable
from ...extern.six.moves import zip, range, cStringIO as StringIO
try:
with ignore_warnings(DeprecationWarning):
# Ignore DeprecationWarning on pandas import in Python 3.5--see
# https://github.com/astropy/astropy/issues/4380
import pandas # pylint: disable=W0611
except ImportError:
HAS_PANDAS = False
else:
HAS_PANDAS = True
class SetupData(object):
def _setup(self, table_types):
self._table_type = table_types.Table
self._column_type = table_types.Column
@property
def a(self):
if self._column_type is not None:
if not hasattr(self, '_a'):
self._a = self._column_type(
[1, 2, 3], name='a', format='%d',
meta={'aa': [0, 1, 2, 3, 4]})
return self._a
@property
def b(self):
if self._column_type is not None:
if not hasattr(self, '_b'):
self._b = self._column_type(
[4, 5, 6], name='b', format='%d', meta={'aa': 1})
return self._b
@property
def c(self):
if self._column_type is not None:
if not hasattr(self, '_c'):
self._c = self._column_type([7, 8, 9], 'c')
return self._c
@property
def d(self):
if self._column_type is not None:
if not hasattr(self, '_d'):
self._d = self._column_type([7, 8, 7], 'd')
return self._d
@property
def obj(self):
if self._column_type is not None:
if not hasattr(self, '_obj'):
self._obj = self._column_type([1, 'string', 3], 'obj', dtype='O')
return self._obj
@property
def t(self):
if self._table_type is not None:
if not hasattr(self, '_t'):
self._t = self._table_type([self.a, self.b])
return self._t
@pytest.mark.usefixtures('table_types')
class TestSetTableColumn(SetupData):
def test_set_row(self, table_types):
"""Set a row from a tuple of values"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t[1] = (20, 21)
assert t['a'][0] == 1
assert t['a'][1] == 20
assert t['a'][2] == 3
assert t['b'][0] == 4
assert t['b'][1] == 21
assert t['b'][2] == 6
def test_set_row_existing(self, table_types):
"""Set a row from another existing row"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t[0] = t[1]
assert t[0][0] == 2
assert t[0][1] == 5
def test_set_row_fail_1(self, table_types):
"""Set a row from an incorrectly-sized or typed set of values"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
with pytest.raises(ValueError):
t[1] = (20, 21, 22)
with pytest.raises(TypeError):
t[1] = 0
def test_set_row_fail_2(self, table_types):
"""Set a row from an incorrectly-typed tuple of values"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
with pytest.raises(ValueError):
t[1] = ('abc', 'def')
def test_set_new_col_new_table(self, table_types):
"""Create a new column in empty table using the item access syntax"""
self._setup(table_types)
t = table_types.Table()
t['aa'] = self.a
# Test that the new column name is 'aa' and that the values match
assert np.all(t['aa'] == self.a)
assert t.colnames == ['aa']
def test_set_new_col_new_table_quantity(self, table_types):
"""Create a new column (from a quantity) in empty table using the item access syntax"""
self._setup(table_types)
t = table_types.Table()
t['aa'] = np.array([1, 2, 3]) * u.m
assert np.all(t['aa'] == np.array([1, 2, 3]))
assert t['aa'].unit == u.m
t['bb'] = 3 * u.m
assert np.all(t['bb'] == 3)
assert t['bb'].unit == u.m
def test_set_new_col_existing_table(self, table_types):
"""Create a new column in an existing table using the item access syntax"""
self._setup(table_types)
t = table_types.Table([self.a])
# Add a column
t['bb'] = self.b
assert np.all(t['bb'] == self.b)
assert t.colnames == ['a', 'bb']
assert t['bb'].meta == self.b.meta
assert t['bb'].format == self.b.format
# Add another column
t['c'] = t['a']
assert np.all(t['c'] == t['a'])
assert t.colnames == ['a', 'bb', 'c']
assert t['c'].meta == t['a'].meta
assert t['c'].format == t['a'].format
# Add a multi-dimensional column
t['d'] = table_types.Column(np.arange(12).reshape(3, 2, 2))
assert t['d'].shape == (3, 2, 2)
assert t['d'][0, 0, 1] == 1
# Add column from a list
t['e'] = ['hello', 'the', 'world']
assert np.all(t['e'] == np.array(['hello', 'the', 'world']))
# Make sure setting existing column still works
t['e'] = ['world', 'hello', 'the']
assert np.all(t['e'] == np.array(['world', 'hello', 'the']))
# Add a column via broadcasting
t['f'] = 10
assert np.all(t['f'] == 10)
# Add a column from a Quantity
t['g'] = np.array([1, 2, 3]) * u.m
assert np.all(t['g'].data == np.array([1, 2, 3]))
assert t['g'].unit == u.m
# Add a column from a (scalar) Quantity
t['g'] = 3 * u.m
assert np.all(t['g'].data == 3)
assert t['g'].unit == u.m
def test_set_new_unmasked_col_existing_table(self, table_types):
"""Create a new column in an existing table using the item access syntax"""
self._setup(table_types)
t = table_types.Table([self.a]) # masked or unmasked
b = table.Column(name='b', data=[1, 2, 3]) # unmasked
t['b'] = b
assert np.all(t['b'] == b)
def test_set_new_masked_col_existing_table(self, table_types):
"""Create a new column in an existing table using the item access syntax"""
self._setup(table_types)
t = table_types.Table([self.a]) # masked or unmasked
b = table.MaskedColumn(name='b', data=[1, 2, 3]) # masked
t['b'] = b
assert np.all(t['b'] == b)
def test_set_new_col_existing_table_fail(self, table_types):
"""Generate failure when creating a new column using the item access syntax"""
self._setup(table_types)
t = table_types.Table([self.a])
# Wrong size
with pytest.raises(ValueError):
t['b'] = [1, 2]
@pytest.mark.usefixtures('table_types')
class TestEmptyData():
def test_1(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a', dtype=int, length=100))
assert len(t['a']) == 100
def test_2(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a', dtype=int, shape=(3, ), length=100))
assert len(t['a']) == 100
def test_3(self, table_types):
t = table_types.Table() # length is not given
t.add_column(table_types.Column(name='a', dtype=int))
assert len(t['a']) == 0
def test_4(self, table_types):
t = table_types.Table() # length is not given
t.add_column(table_types.Column(name='a', dtype=int, shape=(3, 4)))
assert len(t['a']) == 0
def test_5(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a')) # dtype is not specified
assert len(t['a']) == 0
def test_add_via_setitem_and_slice(self, table_types):
"""Test related to #3023 where a MaskedColumn is created with name=None
and then gets changed to name='a'. After PR #2790 this test fails
without the #3023 fix."""
t = table_types.Table()
t['a'] = table_types.Column([1, 2, 3])
t2 = t[:]
assert t2.colnames == t.colnames
@pytest.mark.usefixtures('table_types')
class TestNewFromColumns():
def test_simple(self, table_types):
cols = [table_types.Column(name='a', data=[1, 2, 3]),
table_types.Column(name='b', data=[4, 5, 6], dtype=np.float32)]
t = table_types.Table(cols)
assert np.all(t['a'].data == np.array([1, 2, 3]))
assert np.all(t['b'].data == np.array([4, 5, 6], dtype=np.float32))
assert type(t['b'][1]) is np.float32
def test_from_np_array(self, table_types):
cols = [table_types.Column(name='a', data=np.array([1, 2, 3], dtype=np.int64),
dtype=np.float64),
table_types.Column(name='b', data=np.array([4, 5, 6], dtype=np.float32))]
t = table_types.Table(cols)
assert np.all(t['a'] == np.array([1, 2, 3], dtype=np.float64))
assert np.all(t['b'] == np.array([4, 5, 6], dtype=np.float32))
assert type(t['a'][1]) is np.float64
assert type(t['b'][1]) is np.float32
def test_size_mismatch(self, table_types):
cols = [table_types.Column(name='a', data=[1, 2, 3]),
table_types.Column(name='b', data=[4, 5, 6, 7])]
with pytest.raises(ValueError):
table_types.Table(cols)
def test_name_none(self, table_types):
"""Column with name=None can init a table whether or not names are supplied"""
c = table_types.Column(data=[1, 2], name='c')
d = table_types.Column(data=[3, 4])
t = table_types.Table([c, d], names=(None, 'd'))
assert t.colnames == ['c', 'd']
t = table_types.Table([c, d])
assert t.colnames == ['c', 'col1']
@pytest.mark.usefixtures('table_types')
class TestReverse():
def test_reverse(self, table_types):
t = table_types.Table([[1, 2, 3],
['a', 'b', 'cc']])
t.reverse()
assert np.all(t['col0'] == np.array([3, 2, 1]))
assert np.all(t['col1'] == np.array(['cc', 'b', 'a']))
t2 = table_types.Table(t, copy=False)
assert np.all(t2['col0'] == np.array([3, 2, 1]))
assert np.all(t2['col1'] == np.array(['cc', 'b', 'a']))
t2 = table_types.Table(t, copy=True)
assert np.all(t2['col0'] == np.array([3, 2, 1]))
assert np.all(t2['col1'] == np.array(['cc', 'b', 'a']))
t2.sort('col0')
assert np.all(t2['col0'] == np.array([1, 2, 3]))
assert np.all(t2['col1'] == np.array(['a', 'b', 'cc']))
def test_reverse_big(self, table_types):
x = np.arange(10000)
y = x + 1
t = table_types.Table([x, y], names=('x', 'y'))
t.reverse()
assert np.all(t['x'] == x[::-1])
assert np.all(t['y'] == y[::-1])
@pytest.mark.usefixtures('table_types')
class TestColumnAccess():
def test_1(self, table_types):
t = table_types.Table()
with pytest.raises(KeyError):
t['a']
def test_2(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a', data=[1, 2, 3]))
assert np.all(t['a'] == np.array([1, 2, 3]))
with pytest.raises(KeyError):
t['b'] # column does not exist
def test_itercols(self, table_types):
names = ['a', 'b', 'c']
t = table_types.Table([[1], [2], [3]], names=names)
for name, col in zip(names, t.itercols()):
assert name == col.name
assert isinstance(col, table_types.Column)
@pytest.mark.usefixtures('table_types')
class TestAddLength(SetupData):
def test_right_length(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
t.add_column(self.b)
def test_too_long(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
with pytest.raises(ValueError):
t.add_column(table_types.Column(name='b', data=[4, 5, 6, 7])) # data too long
def test_too_short(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
with pytest.raises(ValueError):
t.add_column(table_types.Column(name='b', data=[4, 5])) # data too short
@pytest.mark.usefixtures('table_types')
class TestAddPosition(SetupData):
def test_1(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a, 0)
def test_2(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a, 1)
def test_3(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a, -1)
def test_5(self, table_types):
self._setup(table_types)
t = table_types.Table()
with pytest.raises(ValueError):
t.index_column('b')
def test_6(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a)
t.add_column(self.b)
assert t.columns.keys() == ['a', 'b']
def test_7(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
t.add_column(self.b, t.index_column('a'))
assert t.columns.keys() == ['b', 'a']
def test_8(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
t.add_column(self.b, t.index_column('a') + 1)
assert t.columns.keys() == ['a', 'b']
def test_9(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a)
t.add_column(self.b, t.index_column('a') + 1)
t.add_column(self.c, t.index_column('b'))
assert t.columns.keys() == ['a', 'c', 'b']
def test_10(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a)
ia = t.index_column('a')
t.add_column(self.b, ia + 1)
t.add_column(self.c, ia)
assert t.columns.keys() == ['c', 'a', 'b']
@pytest.mark.usefixtures('table_types')
class TestAddName(SetupData):
def test_override_name(self, table_types):
self._setup(table_types)
t = table_types.Table()
# Check that we can override the name of the input column in the Table
t.add_column(self.a, name='b')
t.add_column(self.b, name='a')
assert t.columns.keys() == ['b', 'a']
# Check that we did not change the name of the input column
assert self.a.info.name == 'a'
assert self.b.info.name == 'b'
# Now test with an input column from another table
t2 = table_types.Table()
t2.add_column(t['a'], name='c')
assert t2.columns.keys() == ['c']
# Check that we did not change the name of the input column
assert t.columns.keys() == ['b', 'a']
# Check that we can give a name if none was present
col = table_types.Column([1, 2, 3])
t.add_column(col, name='c')
assert t.columns.keys() == ['b', 'a', 'c']
def test_default_name(self, table_types):
t = table_types.Table()
col = table_types.Column([1, 2, 3])
t.add_column(col)
assert t.columns.keys() == ['col0']
@pytest.mark.usefixtures('table_types')
class TestInitFromTable(SetupData):
def test_from_table_cols(self, table_types):
"""Ensure that using cols from an existing table gives
a clean copy.
"""
self._setup(table_types)
t = self.t
cols = t.columns
# Construct Table with cols via Table._new_from_cols
t2a = table_types.Table([cols['a'], cols['b'], self.c])
# Construct with add_column
t2b = table_types.Table()
t2b.add_column(cols['a'])
t2b.add_column(cols['b'])
t2b.add_column(self.c)
t['a'][1] = 20
t['b'][1] = 21
for t2 in [t2a, t2b]:
t2['a'][2] = 10
t2['b'][2] = 11
t2['c'][2] = 12
t2.columns['a'].meta['aa'][3] = 10
assert np.all(t['a'] == np.array([1, 20, 3]))
assert np.all(t['b'] == np.array([4, 21, 6]))
assert np.all(t2['a'] == np.array([1, 2, 10]))
assert np.all(t2['b'] == np.array([4, 5, 11]))
assert np.all(t2['c'] == np.array([7, 8, 12]))
assert t2['a'].name == 'a'
assert t2.columns['a'].meta['aa'][3] == 10
assert t.columns['a'].meta['aa'][3] == 3
@pytest.mark.usefixtures('table_types')
class TestAddColumns(SetupData):
def test_add_columns1(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_columns([self.a, self.b, self.c])
assert t.colnames == ['a', 'b', 'c']
def test_add_columns2(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.add_columns([self.c, self.d])
assert t.colnames == ['a', 'b', 'c', 'd']
assert np.all(t['c'] == np.array([7, 8, 9]))
def test_add_columns3(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.add_columns([self.c, self.d], indexes=[1, 0])
assert t.colnames == ['d', 'a', 'c', 'b']
def test_add_columns4(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.add_columns([self.c, self.d], indexes=[0, 0])
assert t.colnames == ['c', 'd', 'a', 'b']
def test_add_columns5(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.add_columns([self.c, self.d], indexes=[2, 2])
assert t.colnames == ['a', 'b', 'c', 'd']
def test_add_columns6(self, table_types):
"""Check that we can override column names."""
self._setup(table_types)
t = table_types.Table()
t.add_columns([self.a, self.b, self.c], names=['b', 'c', 'a'])
assert t.colnames == ['b', 'c', 'a']
def test_add_columns7(self, table_types):
"""Check that default names are used when appropriate."""
t = table_types.Table()
col0 = table_types.Column([1, 2, 3])
col1 = table_types.Column([4, 5, 3])
t.add_columns([col0, col1])
assert t.colnames == ['col0', 'col1']
def test_add_duplicate_column(self, table_types):
self._setup(table_types)
t = table_types.Table()
t.add_column(self.a)
with pytest.raises(ValueError):
t.add_column(table_types.Column(name='a', data=[0, 1, 2]))
t.add_column(table_types.Column(name='a', data=[0, 1, 2]),
rename_duplicate=True)
t.add_column(self.b)
t.add_column(self.c)
assert t.colnames == ['a', 'a_1', 'b', 'c']
t.add_column(table_types.Column(name='a', data=[0, 1, 2]),
rename_duplicate=True)
assert t.colnames == ['a', 'a_1', 'b', 'c', 'a_2']
# test adding column from a separate Table
t1 = table_types.Table()
t1.add_column(self.a)
with pytest.raises(ValueError):
t.add_column(t1['a'])
t.add_column(t1['a'], rename_duplicate=True)
t1['a'][0] = 100 # Change original column
assert t.colnames == ['a', 'a_1', 'b', 'c', 'a_2', 'a_3']
assert t1.colnames == ['a']
# Check new column didn't change (since name conflict forced a copy)
assert t['a_3'][0] == self.a[0]
def test_add_duplicate_columns(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b, self.c])
with pytest.raises(ValueError):
t.add_columns([table_types.Column(name='a', data=[0, 1, 2]), table_types.Column(name='b', data=[0, 1, 2])])
t.add_columns([table_types.Column(name='a', data=[0, 1, 2]),
table_types.Column(name='b', data=[0, 1, 2])],
rename_duplicate=True)
t.add_column(self.d)
assert t.colnames == ['a', 'b', 'c', 'a_1', 'b_1', 'd']
@pytest.mark.usefixtures('table_types')
class TestAddRow(SetupData):
@property
def b(self):
if self._column_type is not None:
if not hasattr(self, '_b'):
self._b = self._column_type(name='b', data=[4.0, 5.1, 6.2])
return self._b
@property
def c(self):
if self._column_type is not None:
if not hasattr(self, '_c'):
self._c = self._column_type(name='c', data=['7', '8', '9'])
return self._c
@property
def d(self):
if self._column_type is not None:
if not hasattr(self, '_d'):
self._d = self._column_type(name='d', data=[[1, 2], [3, 4], [5, 6]])
return self._d
@property
def t(self):
if self._table_type is not None:
if not hasattr(self, '_t'):
self._t = self._table_type([self.a, self.b, self.c])
return self._t
def test_add_none_to_empty_table(self, table_types):
self._setup(table_types)
t = table_types.Table(names=('a', 'b', 'c'), dtype=('(2,)i', 'S4', 'O'))
t.add_row()
assert np.all(t['a'][0] == [0, 0])
assert t['b'][0] == ''
assert t['c'][0] == 0
t.add_row()
assert np.all(t['a'][1] == [0, 0])
assert t['b'][1] == ''
assert t['c'][1] == 0
def test_add_stuff_to_empty_table(self, table_types):
self._setup(table_types)
t = table_types.Table(names=('a', 'b', 'obj'), dtype=('(2,)i', 'S8', 'O'))
t.add_row([[1, 2], 'hello', 'world'])
assert np.all(t['a'][0] == [1, 2])
assert t['b'][0] == 'hello'
assert t['obj'][0] == 'world'
# Make sure it is not repeating last row but instead
# adding zeros (as documented)
t.add_row()
assert np.all(t['a'][1] == [0, 0])
assert t['b'][1] == ''
assert t['obj'][1] == 0
def test_add_table_row(self, table_types):
self._setup(table_types)
t = self.t
t['d'] = self.d
t2 = table_types.Table([self.a, self.b, self.c, self.d])
t.add_row(t2[0])
assert len(t) == 4
assert np.all(t['a'] == np.array([1, 2, 3, 1]))
assert np.allclose(t['b'], np.array([4.0, 5.1, 6.2, 4.0]))
assert np.all(t['c'] == np.array(['7', '8', '9', '7']))
assert np.all(t['d'] == np.array([[1, 2], [3, 4], [5, 6], [1, 2]]))
def test_add_table_row_obj(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b, self.obj])
t.add_row([1, 4.0, [10]])
assert len(t) == 4
assert np.all(t['a'] == np.array([1, 2, 3, 1]))
assert np.allclose(t['b'], np.array([4.0, 5.1, 6.2, 4.0]))
assert np.all(t['obj'] == np.array([1, 'string', 3, [10]], dtype='O'))
def test_add_qtable_row_multidimensional(self):
q = [[1, 2], [3, 4]] * u.m
qt = table.QTable([q])
qt.add_row(([5, 6] * u.km,))
assert np.all(qt['col0'] == [[1, 2], [3, 4], [5000, 6000]] * u.m)
def test_add_with_tuple(self, table_types):
self._setup(table_types)
t = self.t
t.add_row((4, 7.2, '1'))
assert len(t) == 4
assert np.all(t['a'] == np.array([1, 2, 3, 4]))
assert np.allclose(t['b'], np.array([4.0, 5.1, 6.2, 7.2]))
assert np.all(t['c'] == np.array(['7', '8', '9', '1']))
def test_add_with_list(self, table_types):
self._setup(table_types)
t = self.t
t.add_row([4, 7.2, '10'])
assert len(t) == 4
assert np.all(t['a'] == np.array([1, 2, 3, 4]))
assert np.allclose(t['b'], np.array([4.0, 5.1, 6.2, 7.2]))
assert np.all(t['c'] == np.array(['7', '8', '9', '1']))
def test_add_with_dict(self, table_types):
self._setup(table_types)
t = self.t
t.add_row({'a': 4, 'b': 7.2})
assert len(t) == 4
assert np.all(t['a'] == np.array([1, 2, 3, 4]))
assert np.allclose(t['b'], np.array([4.0, 5.1, 6.2, 7.2]))
if t.masked:
assert np.all(t['c'] == np.array(['7', '8', '9', '7']))
else:
assert np.all(t['c'] == np.array(['7', '8', '9', '']))
def test_add_with_none(self, table_types):
self._setup(table_types)
t = self.t
t.add_row()
assert len(t) == 4
assert np.all(t['a'].data == np.array([1, 2, 3, 0]))
assert np.allclose(t['b'], np.array([4.0, 5.1, 6.2, 0.0]))
assert np.all(t['c'].data == np.array(['7', '8', '9', '']))
def test_add_missing_column(self, table_types):
self._setup(table_types)
t = self.t
with pytest.raises(ValueError):
t.add_row({'bad_column': 1})
def test_wrong_size_tuple(self, table_types):
self._setup(table_types)
t = self.t
with pytest.raises(ValueError):
t.add_row((1, 2))
def test_wrong_vals_type(self, table_types):
self._setup(table_types)
t = self.t
with pytest.raises(TypeError):
t.add_row(1)
def test_add_row_failures(self, table_types):
self._setup(table_types)
t = self.t
t_copy = table_types.Table(t, copy=True)
# Wrong number of columns
try:
t.add_row([1, 2, 3, 4])
except ValueError:
pass
assert len(t) == 3
assert np.all(t.as_array() == t_copy.as_array())
# Wrong data type
try:
t.add_row(['one', 2, 3])
except ValueError:
pass
assert len(t) == 3
assert np.all(t.as_array() == t_copy.as_array())
def test_insert_table_row(self, table_types):
"""
Light testing of Table.insert_row() method. The deep testing is done via
the add_row() tests which calls insert_row(index=len(self), ...), so
here just test that the added index parameter is handled correctly.
"""
self._setup(table_types)
row = (10, 40.0, 'x', [10, 20])
for index in range(-3, 4):
indices = np.insert(np.arange(3), index, 3)
t = table_types.Table([self.a, self.b, self.c, self.d])
t2 = t.copy()
t.add_row(row) # By now we know this works
t2.insert_row(index, row)
for name in t.colnames:
if t[name].dtype.kind == 'f':
assert np.allclose(t[name][indices], t2[name])
else:
assert np.all(t[name][indices] == t2[name])
for index in (-4, 4):
t = table_types.Table([self.a, self.b, self.c, self.d])
with pytest.raises(IndexError):
t.insert_row(index, row)
@pytest.mark.usefixtures('table_types')
class TestTableColumn(SetupData):
def test_column_view(self, table_types):
self._setup(table_types)
t = self.t
a = t.columns['a']
a[2] = 10
assert t['a'][2] == 10
@pytest.mark.usefixtures('table_types')
class TestArrayColumns(SetupData):
def test_1d(self, table_types):
self._setup(table_types)
b = table_types.Column(name='b', dtype=int, shape=(2, ), length=3)
t = table_types.Table([self.a])
t.add_column(b)
assert t['b'].shape == (3, 2)
assert t['b'][0].shape == (2, )
def test_2d(self, table_types):
self._setup(table_types)
b = table_types.Column(name='b', dtype=int, shape=(2, 4), length=3)
t = table_types.Table([self.a])
t.add_column(b)
assert t['b'].shape == (3, 2, 4)
assert t['b'][0].shape == (2, 4)
def test_3d(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
b = table_types.Column(name='b', dtype=int, shape=(2, 4, 6), length=3)
t.add_column(b)
assert t['b'].shape == (3, 2, 4, 6)
assert t['b'][0].shape == (2, 4, 6)
@pytest.mark.usefixtures('table_types')
class TestRemove(SetupData):
@property
def t(self):
if self._table_type is not None:
if not hasattr(self, '_t'):
self._t = self._table_type([self.a])
return self._t
@property
def t2(self):
if self._table_type is not None:
if not hasattr(self, '_t2'):
self._t2 = self._table_type([self.a, self.b, self.c])
return self._t2
def test_1(self, table_types):
self._setup(table_types)
self.t.remove_columns('a')
assert self.t.columns.keys() == []
assert self.t.as_array() is None
def test_2(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.remove_columns('a')
assert self.t.columns.keys() == ['b']
assert self.t.dtype.names == ('b',)
assert np.all(self.t['b'] == np.array([4, 5, 6]))
def test_3(self, table_types):
"""Check remove_columns works for a single column with a name of
more than one character. Regression test against #2699"""
self._setup(table_types)
self.t['new_column'] = self.t['a']
assert 'new_column' in self.t.columns.keys()
self.t.remove_columns('new_column')
assert 'new_column' not in self.t.columns.keys()
def test_remove_nonexistent_row(self, table_types):
self._setup(table_types)
with pytest.raises(IndexError):
self.t.remove_row(4)
def test_remove_row_0(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.add_column(self.c)
self.t.remove_row(0)
assert self.t.colnames == ['a', 'b', 'c']
assert np.all(self.t['b'] == np.array([5, 6]))
def test_remove_row_1(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.add_column(self.c)
self.t.remove_row(1)
assert self.t.colnames == ['a', 'b', 'c']
assert np.all(self.t['a'] == np.array([1, 3]))
def test_remove_row_2(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.add_column(self.c)
self.t.remove_row(2)
assert self.t.colnames == ['a', 'b', 'c']
assert np.all(self.t['c'] == np.array([7, 8]))
def test_remove_row_slice(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.add_column(self.c)
self.t.remove_rows(slice(0, 2, 1))
assert self.t.colnames == ['a', 'b', 'c']
assert np.all(self.t['c'] == np.array([9]))
def test_remove_row_list(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.add_column(self.c)
self.t.remove_rows([0, 2])
assert self.t.colnames == ['a', 'b', 'c']
assert np.all(self.t['c'] == np.array([8]))
def test_remove_row_preserves_meta(self, table_types):
self._setup(table_types)
self.t.add_column(self.b)
self.t.remove_rows([0, 2])
assert self.t['a'].meta == {'aa': [0, 1, 2, 3, 4]}
assert self.t.dtype == np.dtype([(str('a'), 'int'),
(str('b'), 'int')])
def test_delitem1(self, table_types):
self._setup(table_types)
del self.t['a']
assert self.t.columns.keys() == []
assert self.t.as_array() is None
def test_delitem2(self, table_types):
self._setup(table_types)
del self.t2['b']
assert self.t2.colnames == ['a', 'c']
def test_delitems(self, table_types):
self._setup(table_types)
del self.t2['a', 'b']
assert self.t2.colnames == ['c']
def test_delitem_fail(self, table_types):
self._setup(table_types)
with pytest.raises(KeyError):
del self.t['d']
@pytest.mark.usefixtures('table_types')
class TestKeep(SetupData):
def test_1(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.keep_columns([])
assert t.columns.keys() == []
assert t.as_array() is None
def test_2(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.keep_columns('b')
assert t.columns.keys() == ['b']
assert t.dtype.names == ('b',)
assert np.all(t['b'] == np.array([4, 5, 6]))
@pytest.mark.usefixtures('table_types')
class TestRename(SetupData):
def test_1(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a])
t.rename_column('a', 'b')
assert t.columns.keys() == ['b']
assert t.dtype.names == ('b',)
assert np.all(t['b'] == np.array([1, 2, 3]))
def test_2(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.rename_column('a', 'c')
t.rename_column('b', 'a')
assert t.columns.keys() == ['c', 'a']
assert t.dtype.names == ('c', 'a')
if t.masked:
assert t.mask.dtype.names == ('c', 'a')
assert np.all(t['c'] == np.array([1, 2, 3]))
assert np.all(t['a'] == np.array([4, 5, 6]))
def test_rename_by_attr(self, table_types):
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t['a'].name = 'c'
t['b'].name = 'a'
assert t.columns.keys() == ['c', 'a']
assert t.dtype.names == ('c', 'a')
assert np.all(t['c'] == np.array([1, 2, 3]))
assert np.all(t['a'] == np.array([4, 5, 6]))
@pytest.mark.usefixtures('table_types')
class TestSort():
def test_single(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a', data=[2, 1, 3]))
t.add_column(table_types.Column(name='b', data=[6, 5, 4]))
t.add_column(table_types.Column(name='c', data=[(1, 2), (3, 4), (4, 5)]))
assert np.all(t['a'] == np.array([2, 1, 3]))
assert np.all(t['b'] == np.array([6, 5, 4]))
t.sort('a')
assert np.all(t['a'] == np.array([1, 2, 3]))
assert np.all(t['b'] == np.array([5, 6, 4]))
assert np.all(t['c'] == np.array([[3, 4],
[1, 2],
[4, 5]]))
t.sort('b')
assert np.all(t['a'] == np.array([3, 1, 2]))
assert np.all(t['b'] == np.array([4, 5, 6]))
assert np.all(t['c'] == np.array([[4, 5],
[3, 4],
[1, 2]]))
def test_single_big(self, table_types):
"""Sort a big-ish table with a non-trivial sort order"""
x = np.arange(10000)
y = np.sin(x)
t = table_types.Table([x, y], names=('x', 'y'))
t.sort('y')
idx = np.argsort(y)
assert np.all(t['x'] == x[idx])
assert np.all(t['y'] == y[idx])
def test_empty(self, table_types):
t = table_types.Table([[], []], dtype=['f4', 'U1'])
t.sort('col1')
def test_multiple(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a', data=[2, 1, 3, 2, 3, 1]))
t.add_column(table_types.Column(name='b', data=[6, 5, 4, 3, 5, 4]))
assert np.all(t['a'] == np.array([2, 1, 3, 2, 3, 1]))
assert np.all(t['b'] == np.array([6, 5, 4, 3, 5, 4]))
t.sort(['a', 'b'])
assert np.all(t['a'] == np.array([1, 1, 2, 2, 3, 3]))
assert np.all(t['b'] == np.array([4, 5, 3, 6, 4, 5]))
t.sort(['b', 'a'])
assert np.all(t['a'] == np.array([2, 1, 3, 1, 3, 2]))
assert np.all(t['b'] == np.array([3, 4, 4, 5, 5, 6]))
t.sort(('a', 'b'))
assert np.all(t['a'] == np.array([1, 1, 2, 2, 3, 3]))
assert np.all(t['b'] == np.array([4, 5, 3, 6, 4, 5]))
def test_multiple_with_bytes(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='firstname', data=[b"Max", b"Jo", b"John"]))
t.add_column(table_types.Column(name='name', data=[b"Miller", b"Miller", b"Jackson"]))
t.add_column(table_types.Column(name='tel', data=[12, 15, 19]))
t.sort(['name', 'firstname'])
assert np.all([t['firstname'] == np.array([b"John", b"Jo", b"Max"])])
assert np.all([t['name'] == np.array([b"Jackson", b"Miller", b"Miller"])])
assert np.all([t['tel'] == np.array([19, 15, 12])])
def test_multiple_with_unicode(self, table_types):
# Before Numpy 1.6.2, sorting with multiple column names
# failed when a unicode column was present.
t = table_types.Table()
t.add_column(table_types.Column(
name='firstname',
data=[six.text_type(x) for x in ["Max", "Jo", "John"]]))
t.add_column(table_types.Column(
name='name',
data=[six.text_type(x) for x in ["Miller", "Miller", "Jackson"]]))
t.add_column(table_types.Column(name='tel', data=[12, 15, 19]))
t.sort(['name', 'firstname'])
assert np.all([t['firstname'] == np.array(
[six.text_type(x) for x in ["John", "Jo", "Max"]])])
assert np.all([t['name'] == np.array(
[six.text_type(x) for x in ["Jackson", "Miller", "Miller"]])])
assert np.all([t['tel'] == np.array([19, 15, 12])])
def test_argsort(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='a', data=[2, 1, 3, 2, 3, 1]))
t.add_column(table_types.Column(name='b', data=[6, 5, 4, 3, 5, 4]))
assert np.all(t.argsort() == t.as_array().argsort())
i0 = t.argsort('a')
i1 = t.as_array().argsort(order=['a'])
assert np.all(t['a'][i0] == t['a'][i1])
i0 = t.argsort(['a', 'b'])
i1 = t.as_array().argsort(order=['a', 'b'])
assert np.all(t['a'][i0] == t['a'][i1])
assert np.all(t['b'][i0] == t['b'][i1])
def test_argsort_bytes(self, table_types):
t = table_types.Table()
t.add_column(table_types.Column(name='firstname', data=[b"Max", b"Jo", b"John"]))
t.add_column(table_types.Column(name='name', data=[b"Miller", b"Miller", b"Jackson"]))
t.add_column(table_types.Column(name='tel', data=[12, 15, 19]))
assert np.all(t.argsort(['name', 'firstname']) == np.array([2, 1, 0]))
def test_argsort_unicode(self, table_types):
# Before Numpy 1.6.2, sorting with multiple column names
# failed when a unicode column was present.
t = table_types.Table()
t.add_column(table_types.Column(
name='firstname',
data=[six.text_type(x) for x in ["Max", "Jo", "John"]]))
t.add_column(table_types.Column(
name='name',
data=[six.text_type(x) for x in ["Miller", "Miller", "Jackson"]]))
t.add_column(table_types.Column(name='tel', data=[12, 15, 19]))
assert np.all(t.argsort(['name', 'firstname']) == np.array([2, 1, 0]))
def test_rebuild_column_view_then_rename(self, table_types):
"""
Issue #2039 where renaming fails after any method that calls
_rebuild_table_column_view (this includes sort and add_row).
"""
t = table_types.Table([[1]], names=('a',))
assert t.colnames == ['a']
assert t.dtype.names == ('a',)
t.add_row((2,))
assert t.colnames == ['a']
assert t.dtype.names == ('a',)
t.rename_column('a', 'b')
assert t.colnames == ['b']
assert t.dtype.names == ('b',)
t.sort('b')
assert t.colnames == ['b']
assert t.dtype.names == ('b',)
t.rename_column('b', 'c')
assert t.colnames == ['c']
assert t.dtype.names == ('c',)
@pytest.mark.usefixtures('table_types')
class TestIterator():
def test_iterator(self, table_types):
d = np.array([(2, 1),
(3, 6),
(4, 5)], dtype=[(str('a'), 'i4'), (str('b'), 'i4')])
t = table_types.Table(d)
if t.masked:
with pytest.raises(ValueError):
t[0] == d[0]
else:
for row, np_row in zip(t, d):
assert np.all(row == np_row)
@pytest.mark.usefixtures('table_types')
class TestSetMeta():
def test_set_meta(self, table_types):
d = table_types.Table(names=('a', 'b'))
d.meta['a'] = 1
d.meta['b'] = 1
d.meta['c'] = 1
d.meta['d'] = 1
assert list(d.meta.keys()) == ['a', 'b', 'c', 'd']
@pytest.mark.usefixtures('table_types')
class TestConvertNumpyArray():
def test_convert_numpy_array(self, table_types):
d = table_types.Table([[1, 2], [3, 4]], names=('a', 'b'))
np_data = np.array(d)
if table_types.Table is not MaskedTable:
assert np.all(np_data == d.as_array())
assert np_data is not d.as_array()
assert d.colnames == list(np_data.dtype.names)
np_data = np.array(d, copy=False)
if table_types.Table is not MaskedTable:
assert np.all(np_data == d.as_array())
assert d.colnames == list(np_data.dtype.names)
with pytest.raises(ValueError):
np_data = np.array(d, dtype=[(str('c'), 'i8'), (str('d'), 'i8')])
def test_as_array_byteswap(self, table_types):
"""Test for https://github.com/astropy/astropy/pull/4080"""
byte_orders = ('>', '<')
native_order = byte_orders[sys.byteorder == 'little']
for order in byte_orders:
col = table_types.Column([1.0, 2.0], name='a', dtype=order + 'f8')
t = table_types.Table([col])
arr = t.as_array()
assert arr['a'].dtype.byteorder in (native_order, '=')
arr = t.as_array(keep_byteorder=True)
if order == native_order:
assert arr['a'].dtype.byteorder in (order, '=')
else:
assert arr['a'].dtype.byteorder == order
def test_byteswap_fits_array(self, table_types):
"""
Test for https://github.com/astropy/astropy/pull/4080, demonstrating
that FITS tables are converted to native byte order.
"""
non_native_order = ('>', '<')[sys.byteorder != 'little']
filename = get_pkg_data_filename('data/tb.fits',
'astropy.io.fits.tests')
t = table_types.Table.read(filename)
arr = t.as_array()
for idx in range(len(arr.dtype)):
assert arr.dtype[idx].byteorder != non_native_order
with fits.open(filename) as hdul:
data = hdul[1].data
for colname in data.columns.names:
assert np.all(data[colname] == arr[colname])
arr2 = t.as_array(keep_byteorder=True)
for colname in data.columns.names:
assert (data[colname].dtype.byteorder ==
arr2[colname].dtype.byteorder)
def _assert_copies(t, t2, deep=True):
assert t.colnames == t2.colnames
np.testing.assert_array_equal(t.as_array(), t2.as_array())
assert t.meta == t2.meta
for col, col2 in zip(t.columns.values(), t2.columns.values()):
if deep:
assert not np.may_share_memory(col, col2)
else:
assert np.may_share_memory(col, col2)
def test_copy():
t = table.Table([[1, 2, 3], [2, 3, 4]], names=['x', 'y'])
t2 = t.copy()
_assert_copies(t, t2)
def test_copy_masked():
t = table.Table([[1, 2, 3], [2, 3, 4]], names=['x', 'y'], masked=True,
meta={'name': 'test'})
t['x'].mask == [True, False, True]
t2 = t.copy()
_assert_copies(t, t2)
def test_copy_protocol():
t = table.Table([[1, 2, 3], [2, 3, 4]], names=['x', 'y'])
t2 = copy.copy(t)
t3 = copy.deepcopy(t)
_assert_copies(t, t2, deep=False)
_assert_copies(t, t3)
def test_disallow_inequality_comparisons():
"""
Regression test for #828 - disallow comparison operators on whole Table
"""
t = table.Table()
with pytest.raises(TypeError):
t > 2
with pytest.raises(TypeError):
t < 1.1
with pytest.raises(TypeError):
t >= 5.5
with pytest.raises(TypeError):
t <= -1.1
def test_equality():
t = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 2 b 6.0 2',
' 2 a 4.0 3',
' 0 a 0.0 4',
' 1 b 3.0 5',
' 1 a 2.0 6',
' 1 a 1.0 7',
], format='ascii')
# All rows are equal
assert np.all(t == t)
# Assert no rows are different
assert not np.any(t != t)
# Check equality result for a given row
assert np.all((t == t[3]) == np.array([0, 0, 0, 1, 0, 0, 0, 0], dtype=bool))
# Check inequality result for a given row
assert np.all((t != t[3]) == np.array([1, 1, 1, 0, 1, 1, 1, 1], dtype=bool))
t2 = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 3 b 6.0 2',
' 2 a 4.0 3',
' 0 a 1.0 4',
' 1 b 3.0 5',
' 1 c 2.0 6',
' 1 a 1.0 7',
], format='ascii')
# In the above cases, Row.__eq__ gets called, but now need to make sure
# Table.__eq__ also gets called.
assert np.all((t == t2) == np.array([1, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
assert np.all((t != t2) == np.array([0, 0, 1, 0, 1, 0, 1, 0], dtype=bool))
# Check that comparing to a structured array works
assert np.all((t == t2.as_array()) == np.array([1, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
assert np.all((t.as_array() == t2) == np.array([1, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
def test_equality_masked():
t = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 2 b 6.0 2',
' 2 a 4.0 3',
' 0 a 0.0 4',
' 1 b 3.0 5',
' 1 a 2.0 6',
' 1 a 1.0 7',
], format='ascii')
# Make into masked table
t = table.Table(t, masked=True)
# All rows are equal
assert np.all(t == t)
# Assert no rows are different
assert not np.any(t != t)
# Check equality result for a given row
assert np.all((t == t[3]) == np.array([0, 0, 0, 1, 0, 0, 0, 0], dtype=bool))
# Check inequality result for a given row
assert np.all((t != t[3]) == np.array([1, 1, 1, 0, 1, 1, 1, 1], dtype=bool))
t2 = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 3 b 6.0 2',
' 2 a 4.0 3',
' 0 a 1.0 4',
' 1 b 3.0 5',
' 1 c 2.0 6',
' 1 a 1.0 7',
], format='ascii')
# In the above cases, Row.__eq__ gets called, but now need to make sure
# Table.__eq__ also gets called.
assert np.all((t == t2) == np.array([1, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
assert np.all((t != t2) == np.array([0, 0, 1, 0, 1, 0, 1, 0], dtype=bool))
# Check that masking a value causes the row to differ
t.mask['a'][0] = True
assert np.all((t == t2) == np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
assert np.all((t != t2) == np.array([1, 0, 1, 0, 1, 0, 1, 0], dtype=bool))
# Check that comparing to a structured array works
assert np.all((t == t2.as_array()) == np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
@pytest.mark.xfail
def test_equality_masked_bug():
"""
This highlights a Numpy bug. Once it works, it can be moved into the
test_equality_masked test. Related Numpy bug report:
https://github.com/numpy/numpy/issues/3840
"""
t = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 2 b 6.0 2',
' 2 a 4.0 3',
' 0 a 0.0 4',
' 1 b 3.0 5',
' 1 a 2.0 6',
' 1 a 1.0 7',
], format='ascii')
t = table.Table(t, masked=True)
t2 = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 3 b 6.0 2',
' 2 a 4.0 3',
' 0 a 1.0 4',
' 1 b 3.0 5',
' 1 c 2.0 6',
' 1 a 1.0 7',
], format='ascii')
assert np.all((t.as_array() == t2) == np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=bool))
# Check that the meta descriptor is working as expected. The MetaBaseTest class
# takes care of defining all the tests, and we simply have to define the class
# and any minimal set of args to pass.
from ...utils.tests.test_metadata import MetaBaseTest
class TestMetaTable(MetaBaseTest):
test_class = table.Table
args = ()
def test_unicode_column_names(table_types):
"""
Test that unicode column names are accepted. Only do this for
Python 2 since strings are unicode already in Python 3.
"""
if six.PY2:
t = table_types.Table([[1]], names=(six.text_type('a'),))
assert t.colnames == ['a']
t[six.text_type('b')] = 0.0
assert t.colnames == ['a', 'b']
def test_unicode_content():
# If we don't have unicode literals then return
if isinstance('', bytes):
return
# Define unicode literals
string_a = 'астрономическая питона'
string_b = 'миллиарды световых лет'
a = table.Table(
[[string_a, 2],
[string_b, 3]],
names=('a', 'b'))
assert string_a in six.text_type(a)
# This only works because the coding of this file is utf-8, which
# matches the default encoding of Table.__str__
assert string_a.encode('utf-8') in bytes(a)
def test_unicode_policy():
t = table.Table.read([' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 2 b 6.0 2',
' 2 a 4.0 3',
' 0 a 0.0 4',
' 1 b 3.0 5',
' 1 a 2.0 6',
' 1 a 1.0 7',
], format='ascii')
assert_follows_unicode_guidelines(t)
def test_unicode_bytestring_conversion(table_types):
t = table_types.Table([['abc'], ['def'], [1]], dtype=('S', 'U', 'i'))
assert t['col0'].dtype.kind == 'S'
assert t['col1'].dtype.kind == 'U'
assert t['col2'].dtype.kind == 'i'
t1 = t.copy()
t1.convert_unicode_to_bytestring()
assert t1['col0'].dtype.kind == 'S'
assert t1['col1'].dtype.kind == 'S'
assert t1['col2'].dtype.kind == 'i'
assert t1['col0'][0] == 'abc'
assert t1['col1'][0] == 'def'
assert t1['col2'][0] == 1
t1 = t.copy()
t1.convert_bytestring_to_unicode()
assert t1['col0'].dtype.kind == 'U'
assert t1['col1'].dtype.kind == 'U'
assert t1['col2'].dtype.kind == 'i'
assert t1['col0'][0] == six.text_type('abc')
assert t1['col1'][0] == six.text_type('def')
assert t1['col2'][0] == 1
def test_table_deletion():
"""
Regression test for the reference cycle discussed in
https://github.com/astropy/astropy/issues/2877
"""
deleted = set()
# A special table subclass which leaves a record when it is finalized
class TestTable(table.Table):
def __del__(self):
deleted.add(id(self))
t = TestTable({'a': [1, 2, 3]})
the_id = id(t)
assert t['a'].parent_table is t
del t
# Cleanup
gc.collect()
assert the_id in deleted
def test_nested_iteration():
"""
Regression test for issue 3358 where nested iteration over a single table fails.
"""
t = table.Table([[0, 1]], names=['a'])
out = []
for r1 in t:
for r2 in t:
out.append((r1['a'], r2['a']))
assert out == [(0, 0), (0, 1), (1, 0), (1, 1)]
def test_table_init_from_degenerate_arrays(table_types):
t = table_types.Table(np.array([]))
assert len(t.columns) == 0
with pytest.raises(ValueError):
t = table_types.Table(np.array(0))
t = table_types.Table(np.array([1, 2, 3]))
assert len(t.columns) == 3
@pytest.mark.skipif('not HAS_PANDAS')
class TestPandas(object):
def test_simple(self):
t = table.Table()
for endian in ['<', '>']:
for kind in ['f', 'i']:
for byte in ['2', '4', '8']:
dtype = np.dtype(endian + kind + byte)
x = np.array([1, 2, 3], dtype=dtype)
t[endian + kind + byte] = x
t['u'] = ['a', 'b', 'c']
t['s'] = ['a', 'b', 'c']
d = t.to_pandas()
for column in t.columns:
if column == 'u':
assert np.all(t['u'] == np.array(['a', 'b', 'c']))
assert d[column].dtype == np.dtype("O") # upstream feature of pandas
elif column == 's':
assert np.all(t['s'] == np.array(['a', 'b', 'c']))
assert d[column].dtype == np.dtype("O") # upstream feature of pandas
else:
# We should be able to compare exact values here
assert np.all(t[column] == d[column])
if t[column].dtype.byteorder in ('=', '|'):
assert d[column].dtype == t[column].dtype
else:
assert d[column].dtype == t[column].byteswap().newbyteorder().dtype
# Regression test for astropy/astropy#1156 - the following code gave a
# ValueError: Big-endian buffer not supported on little-endian
# compiler. We now automatically swap the endian-ness to native order
# upon adding the arrays to the data frame.
d[['<i4', '>i4']]
d[['<f4', '>f4']]
t2 = table.Table.from_pandas(d)
for column in t.columns:
if column in ('u', 's'):
assert np.all(t[column] == t2[column])
else:
assert_allclose(t[column], t2[column])
if t[column].dtype.byteorder in ('=', '|'):
assert t[column].dtype == t2[column].dtype
else:
assert t[column].byteswap().newbyteorder().dtype == t2[column].dtype
def test_2d(self):
t = table.Table()
t['a'] = [1, 2, 3]
t['b'] = np.ones((3, 2))
with pytest.raises(ValueError) as exc:
t.to_pandas()
assert exc.value.args[0] == "Cannot convert a table with multi-dimensional columns to a pandas DataFrame"
def test_mixin(self):
from ...coordinates import SkyCoord
t = table.Table()
t['c'] = SkyCoord([1, 2, 3], [4, 5, 6], unit='deg')
with pytest.raises(ValueError) as exc:
t.to_pandas()
assert exc.value.args[0] == "Cannot convert a table with mixin columns to a pandas DataFrame"
def test_masking(self):
t = table.Table(masked=True)
t['a'] = [1, 2, 3]
t['a'].mask = [True, False, True]
t['b'] = [1., 2., 3.]
t['b'].mask = [False, False, True]
t['u'] = ['a', 'b', 'c']
t['u'].mask = [False, True, False]
t['s'] = ['a', 'b', 'c']
t['s'].mask = [False, True, False]
d = t.to_pandas()
t2 = table.Table.from_pandas(d)
for name, column in t.columns.items():
assert np.all(column.data == t2[name].data)
assert np.all(column.mask == t2[name].mask)
# Masked integer type comes back as float. Nothing we can do about this.
if column.dtype.kind == 'i':
assert t2[name].dtype.kind == 'f'
else:
if column.dtype.byteorder in ('=', '|'):
assert column.dtype == t2[name].dtype
else:
assert column.byteswap().newbyteorder().dtype == t2[name].dtype
@pytest.mark.usefixtures('table_types')
class TestReplaceColumn(SetupData):
def test_fail_replace_column(self, table_types):
"""Raise exception when trying to replace column via table.columns object"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
with pytest.raises(ValueError):
t.columns['a'] = [1, 2, 3]
with pytest.raises(ValueError):
t.replace_column('not there', [1, 2, 3])
def test_replace_column(self, table_types):
"""Replace existing column with a new column"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
ta = t['a']
tb = t['b']
vals = [1.2, 3.4, 5.6]
for col in (vals,
table_types.Column(vals),
table_types.Column(vals, name='a'),
table_types.Column(vals, name='b')):
t.replace_column('a', col)
assert np.all(t['a'] == vals)
assert t['a'] is not ta # New a column
assert t['b'] is tb # Original b column unchanged
assert t.colnames == ['a', 'b']
assert t['a'].meta == {}
assert t['a'].format is None
def test_replace_index_column(self, table_types):
"""Replace index column and generate expected exception"""
self._setup(table_types)
t = table_types.Table([self.a, self.b])
t.add_index('a')
with pytest.raises(ValueError) as err:
t.replace_column('a', [1, 2, 3])
assert err.value.args[0] == 'cannot replace a table index column'
class Test__Astropy_Table__():
"""
Test initializing a Table subclass from a table-like object that
implements the __astropy_table__ interface method.
"""
class SimpleTable(object):
def __init__(self):
self.columns = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9] * u.m]
self.names = ['a', 'b', 'c']
self.meta = OrderedDict([('a', 1), ('b', 2)])
def __astropy_table__(self, cls, copy, **kwargs):
a, b, c = self.columns
c.info.name = 'c'
cols = [table.Column(a, name='a'),
table.MaskedColumn(b, name='b'),
c]
names = [col.info.name for col in cols]
return cls(cols, names=names, copy=copy, meta=kwargs or self.meta)
def test_simple_1(self):
"""Make a SimpleTable and convert to Table, QTable with copy=False, True"""
for table_cls in (table.Table, table.QTable):
col_c_class = u.Quantity if table_cls is table.QTable else table.MaskedColumn
for cpy in (False, True):
st = self.SimpleTable()
# Test putting in a non-native kwarg `extra_meta` to Table initializer
t = table_cls(st, copy=cpy, extra_meta='extra!')
assert t.colnames == ['a', 'b', 'c']
assert t.meta == {'extra_meta': 'extra!'}
assert np.all(t['a'] == st.columns[0])
assert np.all(t['b'] == st.columns[1])
vals = t['c'].value if table_cls is table.QTable else t['c']
assert np.all(st.columns[2].value == vals)
assert isinstance(t['a'], table.MaskedColumn)
assert isinstance(t['b'], table.MaskedColumn)
assert isinstance(t['c'], col_c_class)
assert t['c'].unit is u.m
assert type(t) is table_cls
# Copy being respected?
t['a'][0] = 10
assert st.columns[0][0] == 1 if cpy else 10
def test_simple_2(self):
"""Test converting a SimpleTable and changing column names and types"""
st = self.SimpleTable()
dtypes = [np.int32, np.float32, np.float16]
names = ['a', 'b', 'c']
t = table.Table(st, dtype=dtypes, names=names, meta=OrderedDict([('c', 3)]))
assert t.colnames == names
assert all(col.dtype.type is dtype
for col, dtype in zip(t.columns.values(), dtypes))
# The supplied meta is ignored. This is consistent with current
# behavior when initializing from an existing astropy Table.
assert t.meta == st.meta
def test_kwargs_exception(self):
"""If extra kwargs provided but without initializing with a table-like
object, exception is raised"""
with pytest.raises(TypeError) as err:
table.Table([[1]], extra_meta='extra!')
assert '__init__() got unexpected keyword argument' in str(err)
def test_replace_column_qtable():
"""Replace existing Quantity column with a new column in a QTable"""
a = [1, 2, 3] * u.m
b = [4, 5, 6]
t = table.QTable([a, b], names=['a', 'b'])
ta = t['a']
tb = t['b']
ta.info.meta = {'aa': [0, 1, 2, 3, 4]}
ta.info.format = '%f'
t.replace_column('a', a.to('cm'))
assert np.all(t['a'] == ta)
assert t['a'] is not ta # New a column
assert t['b'] is tb # Original b column unchanged
assert t.colnames == ['a', 'b']
assert t['a'].info.meta is None
assert t['a'].info.format is None
def test_replace_update_column_via_setitem():
"""
Test table update like ``t['a'] = value``. This leverages off the
already well-tested ``replace_column`` and in-place update
``t['a'][:] = value``, so this testing is fairly light.
"""
a = [1, 2] * u.m
b = [3, 4]
t = table.QTable([a, b], names=['a', 'b'])
assert isinstance(t['a'], u.Quantity)
# Inplace update
ta = t['a']
t['a'] = 5 * u.m
assert np.all(t['a'] == [5, 5] * u.m)
assert t['a'] is ta
# Replace
t['a'] = [5, 6]
assert np.all(t['a'] == [5, 6])
assert isinstance(t['a'], table.Column)
assert t['a'] is not ta
def test_replace_update_column_via_setitem_warnings_normal():
"""
Test warnings related to table replace change in #5556:
Normal warning-free replace
"""
t = table.Table([[1, 2, 3], [4, 5, 6]], names=['a', 'b'])
with catch_warnings() as w:
with table.conf.set_temp('replace_warnings',
['refcount', 'attributes', 'slice']):
t['a'] = 0 # in-place update
assert len(w) == 0
t['a'] = [10, 20, 30] # replace column
assert len(w) == 0
def test_replace_update_column_via_setitem_warnings_slice():
"""
Test warnings related to table replace change in #5556:
Replace a slice, one warning.
"""
t = table.Table([[1, 2, 3], [4, 5, 6]], names=['a', 'b'])
with catch_warnings() as w:
with table.conf.set_temp('replace_warnings',
['refcount', 'attributes', 'slice']):
t2 = t[:2]
t2['a'] = 0 # in-place slice update
assert np.all(t['a'] == [0, 0, 3])
assert len(w) == 0
t2['a'] = [10, 20] # replace slice
assert len(w) == 1
assert "replaced column 'a' which looks like an array slice" in str(w[0].message)
def test_replace_update_column_via_setitem_warnings_attributes():
"""
Test warnings related to table replace change in #5556:
Lost attributes.
"""
t = table.Table([[1, 2, 3], [4, 5, 6]], names=['a', 'b'])
t['a'].unit = 'm'
with catch_warnings() as w:
with table.conf.set_temp('replace_warnings',
['refcount', 'attributes', 'slice']):
t['a'] = [10, 20, 30]
assert len(w) == 1
assert "replaced column 'a' and column attributes ['unit']" in str(w[0].message)
def test_replace_update_column_via_setitem_warnings_refcount():
"""
Test warnings related to table replace change in #5556:
Reference count changes.
"""
t = table.Table([[1, 2, 3], [4, 5, 6]], names=['a', 'b'])
ta = t['a'] # Generate an extra reference to original column
with catch_warnings() as w:
with table.conf.set_temp('replace_warnings',
['refcount', 'attributes', 'slice']):
t['a'] = [10, 20, 30]
assert len(w) == 1
assert "replaced column 'a' and the number of references" in str(w[0].message)
def test_replace_update_column_via_setitem_warnings_always():
"""
Test warnings related to table replace change in #5556:
Test 'always' setting that raises warning for any replace.
"""
t = table.Table([[1, 2, 3], [4, 5, 6]], names=['a', 'b'])
with catch_warnings() as w:
with table.conf.set_temp('replace_warnings', ['always']):
t['a'] = 0 # in-place slice update
assert len(w) == 0
from inspect import currentframe, getframeinfo
frameinfo = getframeinfo(currentframe())
t['a'] = [10, 20, 30] # replace column
assert len(w) == 1
assert "replaced column 'a'" == str(w[0].message)
# Make sure the warning points back to the user code line
assert w[0].lineno == frameinfo.lineno + 1
assert w[0].category is table.TableReplaceWarning
assert 'test_table' in w[0].filename
def test_replace_update_column_via_setitem_replace_inplace():
"""
Test the replace_inplace config option related to #5556. In this
case no replace is done.
"""
t = table.Table([[1, 2, 3], [4, 5, 6]], names=['a', 'b'])
ta = t['a']
t['a'].unit = 'm'
with catch_warnings() as w:
with table.conf.set_temp('replace_inplace', True):
with table.conf.set_temp('replace_warnings',
['always', 'refcount', 'attributes', 'slice']):
t['a'] = 0 # in-place update
assert len(w) == 0
assert ta is t['a']
t['a'] = [10, 20, 30] # normally replaces column, but not now
assert len(w) == 0
assert ta is t['a']
assert np.all(t['a'] == [10, 20, 30])
def test_primary_key_is_inherited():
"""Test whether a new Table inherits the primary_key attribute from
its parent Table. Issue #4672"""
t = table.Table([(2, 3, 2, 1), (8, 7, 6, 5)], names=('a', 'b'))
t.add_index('a')
original_key = t.primary_key
# can't test if tuples are equal, so just check content
assert original_key[0] is 'a'
t2 = t[:]
t3 = t.copy()
t4 = table.Table(t)
# test whether the reference is the same in the following
assert original_key == t2.primary_key
assert original_key == t3.primary_key
assert original_key == t4.primary_key
# just test one element, assume rest are equal if assert passes
assert t.loc[1] == t2.loc[1]
assert t.loc[1] == t3.loc[1]
assert t.loc[1] == t4.loc[1]
def test_qtable_read_for_ipac_table_with_char_columns():
'''Test that a char column of a QTable is assigned no unit and not
a dimensionless unit, otherwise conversion of reader output to
QTable fails.'''
t1 = table.QTable([["A"]], names="B")
out = StringIO()
t1.write(out, format="ascii.ipac")
t2 = table.QTable.read(out.getvalue(), format="ascii.ipac", guess=False)
assert t2["B"].unit is None
| bsd-3-clause |
alexeyum/scikit-learn | examples/linear_model/plot_ridge_path.py | 55 | 2138 | """
===========================================================
Plot Ridge coefficients as a function of the regularization
===========================================================
Shows the effect of collinearity in the coefficients of an estimator.
.. currentmodule:: sklearn.linear_model
:class:`Ridge` Regression is the estimator used in this example.
Each color represents a different feature of the
coefficient vector, and this is displayed as a function of the
regularization parameter.
This example also shows the usefulness of applying Ridge regression
to highly ill-conditioned matrices. For such matrices, a slight
change in the target variable can cause huge variances in the
calculated weights. In such cases, it is useful to set a certain
regularization (alpha) to reduce this variation (noise).
When alpha is very large, the regularization effect dominates the
squared loss function and the coefficients tend to zero.
At the end of the path, as alpha tends toward zero
and the solution tends towards the ordinary least squares, coefficients
exhibit big oscillations. In practise it is necessary to tune alpha
in such a way that a balance is maintained between both.
"""
# Author: Fabian Pedregosa -- <[email protected]>
# License: BSD 3 clause
print(__doc__)
import numpy as np
import matplotlib.pyplot as plt
from sklearn import linear_model
# X is the 10x10 Hilbert matrix
X = 1. / (np.arange(1, 11) + np.arange(0, 10)[:, np.newaxis])
y = np.ones(10)
###############################################################################
# Compute paths
n_alphas = 200
alphas = np.logspace(-10, -2, n_alphas)
clf = linear_model.Ridge(fit_intercept=False)
coefs = []
for a in alphas:
clf.set_params(alpha=a)
clf.fit(X, y)
coefs.append(clf.coef_)
###############################################################################
# Display results
ax = plt.gca()
ax.plot(alphas, coefs)
ax.set_xscale('log')
ax.set_xlim(ax.get_xlim()[::-1]) # reverse axis
plt.xlabel('alpha')
plt.ylabel('weights')
plt.title('Ridge coefficients as a function of the regularization')
plt.axis('tight')
plt.show()
| bsd-3-clause |
peterfpeterson/mantid | qt/applications/workbench/workbench/plotting/mantidfigurecanvas.py | 3 | 2785 | # Mantid Repository : https://github.com/mantidproject/mantid
#
# Copyright © 2020 ISIS Rutherford Appleton Laboratory UKRI,
# NScD Oak Ridge National Laboratory, European Spallation Source,
# Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
# SPDX - License - Identifier: GPL - 3.0 +
# This file is part of the mantid workbench.
"""
Qt-based matplotlib canvas
"""
from qtpy.QtCore import Qt
from qtpy.QtGui import QPen
from matplotlib.backends.backend_qt5agg import ( # noqa: F401
FigureCanvasQTAgg, draw_if_interactive, show)
from mantid.plots.mantidimage import MantidImage, ImageIntensity
class MantidFigureCanvas(FigureCanvasQTAgg):
def __init__(self, figure):
super().__init__(figure=figure)
self._pen_color = Qt.black
self._pen_thickness = 1.5
# options controlling the pen used by tools that manipulate the graph - e.g the zoom box
@property
def pen_color(self):
return self._pen_color
@pen_color.setter
def pen_color(self, color):
self._pen_color = color
@property
def pen_thickness(self):
return self._pen_thickness
@pen_thickness.setter
def pen_thickness(self, thickness):
self._pen_thickness = thickness
# Method used by the zoom box tool on the matplotlib toolbar
def drawRectangle(self, rect):
self.update_pen_color()
# Draw the zoom rectangle to the QPainter. _draw_rect_callback needs
# to be called at the end of paintEvent.
if rect is not None:
def _draw_rect_callback(painter):
pen = QPen(self.pen_color, self.pen_thickness / self._dpi_ratio, Qt.DotLine)
painter.setPen(pen)
painter.drawRect(*(pt / self._dpi_ratio for pt in rect))
else:
def _draw_rect_callback(painter):
return
self._draw_rect_callback = _draw_rect_callback
self.update()
def update_pen_color(self):
"""Update the pen color used to draw tool in the matplotlib toolbar, e.g
the zoombox. The color is automatically determined
by considering how dark, or light the image is and setting a pen appropriately.
Only works if the figure contains a MantidImage.
"""
for ax in self.figure.get_axes():
for img in ax.get_images():
if (not isinstance(img, MantidImage)):
continue
intensity = img.calculate_greyscale_intensity()
if intensity == ImageIntensity.DARK:
color = Qt.white
else:
color = Qt.black
self.pen_color = color
# break after we find the first MantidImage
break
| gpl-3.0 |
kedz/cuttsum | wp-scripts/make-lm-dev.py | 1 | 6784 | import corenlp as cnlp
import re
import os
import gzip
import cuttsum.events
import cuttsum.judgements
import pandas as pd
from collections import defaultdict
matches_df = cuttsum.judgements.get_merged_dataframe()
def heal_text(sent_text):
sent_text = sent_text.decode("utf-8")
sent_text = re.sub(
ur"[a-z ]+, [a-z][a-z ]+\( [a-z]+ \) [-\u2014_]+ ",
r"", sent_text)
sent_text = re.sub(
ur"^.*?[a-z ]+, [a-z][a-z]+ [-\u2014_]+ ",
r"", sent_text)
sent_text = re.sub(
ur"^.*?[a-z ]+\([^\)]+\) [-\u2014_]+ ",
r"", sent_text)
sent_text = re.sub(
ur"^.*?[a-z]+ +[-\u2014_]+ ",
r"", sent_text)
sent_text = re.sub(r"\([^)]+\)", r" ", sent_text)
sent_text = re.sub(ur"^ *[-\u2014_]+", r"", sent_text)
sent_text = re.sub(u" ([,.;?!]+)([\"\u201c\u201d'])", r"\1\2", sent_text)
sent_text = re.sub(r" ([:-]) ", r"\1", sent_text)
sent_text = re.sub(r"([^\d]\d{1,3}) , (\d\d\d)([^\d]|$)", r"\1,\2\3", sent_text)
sent_text = re.sub(r"^(\d{1,3}) , (\d\d\d)([^\d]|$)", r"\1,\2\3", sent_text)
sent_text = re.sub(ur" ('|\u2019) ([a-z]|ll|ve|re)( |$)", r"\1\2 ", sent_text)
sent_text = re.sub(r" ([',.;?!]+) ", r"\1 ", sent_text)
sent_text = re.sub(r" ([',.;?!]+)$", r"\1", sent_text)
sent_text = re.sub(r"(\d\.) (\d)", r"\1\2", sent_text)
sent_text = re.sub(r"(a|p)\. m\.", r"\1.m.", sent_text)
sent_text = re.sub(r"u\. (s|n)\.", r"u.\1.", sent_text)
sent_text = re.sub(
ur"\u201c ([^\s])",
ur"\u201c\1", sent_text)
sent_text = re.sub(
ur"([^\s]) \u201d",
ur"\1\u201d", sent_text)
sent_text = re.sub(
ur"\u2018 ([^\s])",
ur"\u2018\1", sent_text)
sent_text = re.sub(
ur"([^\s]) \u2019",
ur"\1\u2019", sent_text)
sent_text = re.sub(
ur"\u00e2",
ur"'", sent_text)
sent_text = re.sub(
r"^photo:reuters|^photo:ap",
r"", sent_text)
sent_text = sent_text.replace("\n", " ")
return sent_text.encode("utf-8")
nuggets = cuttsum.judgements.get_nuggets()
updates = pd.concat([
cuttsum.judgements.get_2013_updates(),
cuttsum.judgements.get_2014_sampled_updates()
])
#updates["text"] = updates["text"].apply(heal_text)
dom2type = {
"accidents": set(["accident"]),
"natural-disasters": set(["earthquake", "storm", "impact event"]),
"social-unrest": set(["protest", "riot"]),
"terrorism": set(["shooting", "bombing", "conflict", "hostage"]),
}
def tokenize(docs, norm, stop, ne, central_per=None, central_loc=None, central_org=None):
if stop:
with open("stopwords.txt", "r") as f:
sw = set([word.strip().decode("utf-8").lower() for word in f])
if norm == "stem":
from nltk.stem.porter import PorterStemmer
stemmer = PorterStemmer()
all_toks = []
for doc in docs:
toks = []
for sent in doc:
if norm == "lemma":
stoks = [unicode(tok.lem).lower() for tok in sent]
elif norm == "stem":
stoks = [stemmer.stem(unicode(tok).lower())
for tok in sent]
else:
stoks = [unicode(tok).lower() for tok in sent]
if stop:
toks.extend([tok for tok in stoks if tok not in sw])
else:
toks.extend(stoks)
toks = [tok for tok in toks if len(tok) < 50]
#if len(toks) == 0: continue
string = u" ".join(toks).encode("utf-8")
#print string
all_toks.append(string)
return all_toks
def find_central_nes(docs):
per_counts = defaultdict(int)
org_counts = defaultdict(int)
loc_counts = defaultdict(int)
for doc in docs:
for sent in doc:
for tok in sent:
if tok.ne == "PERSON":
per_counts[unicode(tok.lem).lower()] += 1
elif tok.ne == "LOCATION":
loc_counts[unicode(tok.lem).lower()] += 1
elif tok.ne == "ORGANIZATION":
org_counts[unicode(tok.lem).lower()] += 1
if len(per_counts) > 0:
central_per = max(per_counts.items(), key=lambda x:[1])[0]
else:
central_per = None
if len(org_counts) > 0:
central_org = max(org_counts.items(), key=lambda x:[1])[0]
else:
central_org = None
if len(loc_counts) > 0:
central_loc = max(loc_counts.items(), key=lambda x:[1])[0]
else:
central_loc = None
return central_per, central_loc, central_org
def main(output_path, norm, stop):
dirname, fname = os.path.split(output_path)
if dirname != "" and not os.path.exists(dirname):
os.makedirs(dirname)
output_path = os.path.join(
dirname,
"{}.norm-{}{}.spl.gz".format(
fname, norm, ".stop" if stop else ""))
print "Domain: {}".format(fname)
print "Output Path: {}".format(output_path)
events = [event for event in cuttsum.events.get_events()
if event.type in dom2type[fname] and event.query_num < 26]
ne = False
#if ne is True:
# annotators = ["tokenize", "ssplit", "pos", "lemma", "ner"]
if norm == "lemma":
annotators = ["tokenize", "ssplit", "pos", "lemma"]
else:
annotators = ["tokenize", "ssplit"]
with cnlp.Server(annotators=annotators, mem="6G",
port=2001, max_message_len=1000000) as client, \
gzip.open(output_path, "w") as f:
query_ids = set([event.query_id for event in events])
updates = matches_df[matches_df["query id"].apply(lambda x: x in query_ids)]
texts = updates.drop_duplicates(subset='update id')["update text"].apply(heal_text).tolist()
central_per = None
central_loc = None
central_org = None
print "processing update text"
docs = [client.annotate(text) for text in texts]
for doc in docs[:10]:
print doc
print "tokenizing"
X_upd_txt = tokenize(docs, norm, stop, ne,
central_per=central_per, central_loc=central_loc,
central_org=central_org)
print "writing"
for line in X_upd_txt:
f.write(line + "\n")
if __name__ == u"__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--output", type=str, required=False, default=None)
parser.add_argument("--norm", choices=["stem", "lemma", "none"], type=str, required=True)
parser.add_argument("--stop", action="store_true", default=False)
args = parser.parse_args()
main(args.output, args.norm, args.stop)
| apache-2.0 |
gVallverdu/pymatgen | pymatgen/io/lammps/tests/test_outputs.py | 4 | 6962 | # coding: utf-8
# Copyright (c) Pymatgen Development Team.
# Distributed under the terms of the MIT License.
import unittest
import os
import json
import numpy as np
import pandas as pd
from pymatgen.io.lammps.outputs import LammpsDump, parse_lammps_dumps, \
parse_lammps_log
test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..", "..",
"test_files", "lammps")
class LammpsDumpTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
with open(os.path.join(test_dir, "dump.rdx_wc.100")) as f:
rdx_str = f.read()
cls.rdx = LammpsDump.from_string(string=rdx_str)
with open(os.path.join(test_dir, "dump.tatb")) as f:
tatb_str = f.read()
cls.tatb = LammpsDump.from_string(string=tatb_str)
def test_from_string(self):
self.assertEqual(self.rdx.timestep, 100)
self.assertEqual(self.rdx.natoms, 21)
np.testing.assert_array_equal(self.rdx.box.bounds,
np.array([(35, 48)] * 3))
np.testing.assert_array_equal(self.rdx.data.columns,
["id", "type", "xs", "ys", "zs"])
rdx_data = self.rdx.data.iloc[-1]
rdx_data_target = [19, 2, 0.42369, 0.47347, 0.555425]
np.testing.assert_array_almost_equal(rdx_data, rdx_data_target)
self.assertEqual(self.tatb.timestep, 0)
self.assertEqual(self.tatb.natoms, 384)
bounds = [[0, 13.624], [0, 17.1149153805], [0, 15.1826391451]]
np.testing.assert_array_almost_equal(self.tatb.box.bounds, bounds)
tilt = [-5.75315630927, -6.325466, 7.4257288]
np.testing.assert_array_almost_equal(self.tatb.box.tilt, tilt)
np.testing.assert_array_equal(self.tatb.data.columns,
["id", "type", "q", "x", "y", "z"])
tatb_data = self.tatb.data.iloc[-1]
tatb_data_target = [356, 3, -0.482096, 2.58647, 12.9577, 14.3143]
np.testing.assert_array_almost_equal(tatb_data, tatb_data_target)
def test_json_dict(self):
encoded = json.dumps(self.rdx.as_dict())
decoded = json.loads(encoded)
rdx = LammpsDump.from_dict(decoded)
self.assertEqual(rdx.timestep, 100)
self.assertEqual(rdx.natoms, 21)
np.testing.assert_array_equal(rdx.box.bounds,
np.array([(35, 48)] * 3))
pd.testing.assert_frame_equal(rdx.data, self.rdx.data)
class FuncTest(unittest.TestCase):
def test_parse_lammps_dumps(self):
# gzipped
rdx_10_pattern = os.path.join(test_dir, "dump.rdx.gz")
rdx_10 = list(parse_lammps_dumps(file_pattern=rdx_10_pattern))
timesteps_10 = [d.timestep for d in rdx_10]
np.testing.assert_array_equal(timesteps_10, np.arange(0, 101, 10))
self.assertTupleEqual(rdx_10[-1].data.shape, (21, 5))
# wildcard
rdx_25_pattern = os.path.join(test_dir, "dump.rdx_wc.*")
rdx_25 = list(parse_lammps_dumps(file_pattern=rdx_25_pattern))
timesteps_25 = [d.timestep for d in rdx_25]
np.testing.assert_array_equal(timesteps_25, np.arange(0, 101, 25))
self.assertTupleEqual(rdx_25[-1].data.shape, (21, 5))
def test_parse_lammps_log(self):
comb_file = "log.5Oct16.comb.Si.elastic.g++.1"
comb = parse_lammps_log(filename=os.path.join(test_dir, comb_file))
self.assertEqual(len(comb), 6)
# first comb run
comb0 = comb[0]
np.testing.assert_array_equal(["Step", "Temp", "TotEng", "PotEng",
"E_vdwl", "E_coul"], comb0.columns)
self.assertEqual(len(comb0), 6)
comb0_data = [[0, 1, -4.6295947, -4.6297237, -4.6297237, 0],
[5, 1, -4.6295965, -4.6297255, -4.6297255, 0]]
np.testing.assert_array_almost_equal(comb0.iloc[[0, -1]], comb0_data)
# final comb run
comb_1 = comb[-1]
np.testing.assert_array_equal(["Step", "Lx", "Ly", "Lz",
"Xy", "Xz", "Yz",
"c_fxy[1]", "c_fxy[2]", "c_fxy[3]",
"c_fxy[4]", "c_fxy[5]", "c_fxy[6]"],
comb_1.columns)
self.assertEqual(len(comb_1), 11)
comb_1_data = [[36, 5.1293854e-06], [46, 2192.8256]]
np.testing.assert_array_almost_equal(comb_1.iloc[[0, -1], [0, -3]],
comb_1_data)
ehex_file = "log.13Oct16.ehex.g++.8"
ehex = parse_lammps_log(filename=os.path.join(test_dir, ehex_file))
self.assertEqual(len(ehex), 3)
ehex0, ehex1, ehex2 = ehex
# ehex run #1
np.testing.assert_array_equal(["Step", "Temp", "E_pair", "E_mol",
"TotEng", "Press"], ehex0.columns)
self.assertEqual(len(ehex0), 11)
ehex0_data = [[0, 1.35, -4.1241917, 0, -2.0994448, -3.1961612],
[1000, 1.3732017, -3.7100044, 0,
-1.6504594, 0.83982701]]
np.testing.assert_array_almost_equal(ehex0.iloc[[0, -1]], ehex0_data)
# ehex run #2
np.testing.assert_array_equal(["Step", "Temp", "c_Thot", "c_Tcold"],
ehex1.columns)
self.assertEqual(len(ehex1), 11)
ehex1_data = [[1000, 1.35, 1.431295, 1.2955644],
[11000, 1.3794051, 1.692299, 1.0515688]]
np.testing.assert_array_almost_equal(ehex1.iloc[[0, -1]], ehex1_data)
# ehex run #3
np.testing.assert_array_equal(["Step", "Temp", "c_Thot", "c_Tcold",
"v_tdiff", "f_ave"], ehex2.columns)
self.assertEqual(len(ehex2), 21)
ehex2_data = [[11000, 1.3794051, 1.6903393, 1.0515688, 0, 0],
[31000, 1.3822489, 1.8220413, 1.0322271, -0.7550338,
-0.76999077]]
np.testing.assert_array_almost_equal(ehex2.iloc[[0, -1]], ehex2_data)
peptide_file = "log.5Oct16.peptide.g++.1"
peptide = parse_lammps_log(filename=os.path.join(test_dir,
peptide_file))
peptide0 = peptide[0]
np.testing.assert_array_equal(["Step", "TotEng", "KinEng", "Temp",
"PotEng", "E_bond", "E_angle",
"E_dihed", "E_impro", "E_vdwl",
"E_coul", "E_long", "Press"],
peptide0.columns)
self.assertEqual(len(peptide0), 7)
peptide0_select = peptide0.loc[[0, 6], ["Step", "TotEng", "Press"]]
peptide0_data = [[0, -5237.4580, -837.0112],
[300, -5251.3637, -471.5505]]
np.testing.assert_array_almost_equal(peptide0_select, peptide0_data)
if __name__ == "__main__":
unittest.main()
| mit |
fegonda/icon_demo | code/model/deleteme/cnn_model.py | 1 | 4305 | #---------------------------------------------------------------------------
# Utility.py
#
# Author : Felix Gonda
# Date : July 10, 2015
# School : Harvard University
#
# Project : Master Thesis
# An Interactive Deep Learning Toolkit for
# Automatic Segmentation of Images
#
# Summary : This file contains utility functions for reading, writing, and
# processing images.
#---------------------------------------------------------------------------
import os
import sys
import time
import ConfigParser
import pandas as pd
import numpy as np
import theano
import theano.tensor as T
import cPickle
theano.config.floatX = 'float32'
base_path = os.path.dirname(__file__)
sys.path.insert(1,os.path.join(base_path, '../external'))
sys.path.insert(2,os.path.join(base_path, '../common'))
sys.path
from logistic_sgd import LogisticRegression
from mlp import HiddenLayer
from mlp_model import MLP_Model
from lenet import LeNetConvPoolLayer
from activation_functions import rectified_linear
class CNN_Model(object):
def __init__(self,
input,
batch_size,
patchSize,
rng,
nkerns,
kernelSizes,
hiddenSizes,
fileName=None,
activation=rectified_linear):
self.convLayers = []
self.trainingCost = []
self.validationError = []
self.nkerns = nkerns
self.kernelSizes = kernelSizes
self.hiddenSizes = hiddenSizes
self.patchSize = patchSize
self.batch_size = batch_size
input = input.reshape((self.batch_size, 1, self.patchSize, self.patchSize))
self.layer0_input = input
self.params = []
input_next = input
numberOfFeatureMaps = 1
featureMapSize = patchSize
for i in range(len(nkerns)):
layer = LeNetConvPoolLayer(
rng,
input=input_next,
image_shape=(batch_size, numberOfFeatureMaps, featureMapSize, featureMapSize),
filter_shape=(nkerns[i], numberOfFeatureMaps, kernelSizes[i], kernelSizes[i]),
poolsize=(2, 2)
)
input_next = layer.output
numberOfFeatureMaps = nkerns[i]
featureMapSize = np.int16(np.floor((featureMapSize - kernelSizes[i]+1) / 2))
self.params += layer.params
self.convLayers.append(layer)
# the 2 is there to preserve the batchSize
mlp_input = self.convLayers[-1].output.flatten(2)
self.mlp = MLP_Model(
rng=rng,
input=mlp_input,
n_in=nkerns[-1] * (featureMapSize ** 2),
n_hidden=hiddenSizes,
n_out=2,
activation=rectified_linear
)
self.params += self.mlp.params
self.cost = self.mlp.negative_log_likelihood
self.errors = self.mlp.errors
self.p_y_given_x = self.mlp.p_y_given_x
self.y_pred = self.mlp.y_pred
self.debug_x = self.p_y_given_x
if not fileName is None:
with open(fileName, 'r') as file:
saved_convLayers,
saved_hiddenLayers,
saved_logRegressionLayer,
self.trainingCost,
self.validationError,
saved_nkerns,
saved_kernelSizes,
saved_batch_size,
saved_patchSize,
saved_hiddenSizes = cPickle.load(file)
for s_cl, cl in zip(saved_convLayers, self.convLayers):
cl.W.set_value(s_cl.W.get_value())
cl.b.set_value(s_cl.b.get_value())
for s_hl, hl in zip(saved_hiddenLayers, self.mlp.hiddenLayers):
hl.W.set_value(np.float32(s_hl.W.eval()))
hl.b.set_value(s_hl.b.get_value())
self.mlp.logRegressionLayer.W.set_value(np.float32(saved_logRegressionLayer.W.eval()))
self.mlp.logRegressionLayer.b.set_value(saved_logRegressionLayer.b.get_value())
def save(self, filename):
with open(filename, 'wb') as file:
cPickle.dump((self.convLayers,
self.mlp.hiddenLayers,
self.mlp.logRegressionLayer,
self.trainingCost,
self.validationError,
self.nkerns,
self.kernelSizes,
self.batch_size,
self.patchSize,
self.hiddenSizes), file)
| mit |
bzero/statsmodels | statsmodels/graphics/tests/test_mosaicplot.py | 17 | 18878 | from __future__ import division
from statsmodels.compat.python import iterkeys, zip, lrange, iteritems, range
from numpy.testing import assert_, assert_raises, dec
from numpy.testing import run_module_suite
# utilities for the tests
from statsmodels.compat.collections import OrderedDict
from statsmodels.api import datasets
import numpy as np
from itertools import product
try:
import matplotlib.pyplot as pylab
have_matplotlib = True
except:
have_matplotlib = False
import pandas
pandas_old = int(pandas.__version__.split('.')[1]) < 9
# the main drawing function
from statsmodels.graphics.mosaicplot import mosaic
# other functions to be tested for accuracy
from statsmodels.graphics.mosaicplot import _hierarchical_split
from statsmodels.graphics.mosaicplot import _reduce_dict
from statsmodels.graphics.mosaicplot import _key_splitting
from statsmodels.graphics.mosaicplot import _normalize_split
from statsmodels.graphics.mosaicplot import _split_rect
@dec.skipif(not have_matplotlib or pandas_old)
def test_data_conversion():
# It will not reorder the elements
# so the dictionary will look odd
# as it key order has the c and b
# keys swapped
import pandas
fig, ax = pylab.subplots(4, 4)
data = {'ax': 1, 'bx': 2, 'cx': 3}
mosaic(data, ax=ax[0, 0], title='basic dict', axes_label=False)
data = pandas.Series(data)
mosaic(data, ax=ax[0, 1], title='basic series', axes_label=False)
data = [1, 2, 3]
mosaic(data, ax=ax[0, 2], title='basic list', axes_label=False)
data = np.asarray(data)
mosaic(data, ax=ax[0, 3], title='basic array', axes_label=False)
data = {('ax', 'cx'): 1, ('bx', 'cx'): 2, ('ax', 'dx'): 3, ('bx', 'dx'): 4}
mosaic(data, ax=ax[1, 0], title='compound dict', axes_label=False)
mosaic(data, ax=ax[2, 0], title='inverted keys dict', index=[1, 0], axes_label=False)
data = pandas.Series(data)
mosaic(data, ax=ax[1, 1], title='compound series', axes_label=False)
mosaic(data, ax=ax[2, 1], title='inverted keys series', index=[1, 0])
data = [[1, 2], [3, 4]]
mosaic(data, ax=ax[1, 2], title='compound list', axes_label=False)
mosaic(data, ax=ax[2, 2], title='inverted keys list', index=[1, 0])
data = np.array([[1, 2], [3, 4]])
mosaic(data, ax=ax[1, 3], title='compound array', axes_label=False)
mosaic(data, ax=ax[2, 3], title='inverted keys array', index=[1, 0], axes_label=False)
gender = ['male', 'male', 'male', 'female', 'female', 'female']
pet = ['cat', 'dog', 'dog', 'cat', 'dog', 'cat']
data = pandas.DataFrame({'gender': gender, 'pet': pet})
mosaic(data, ['gender'], ax=ax[3, 0], title='dataframe by key 1', axes_label=False)
mosaic(data, ['pet'], ax=ax[3, 1], title='dataframe by key 2', axes_label=False)
mosaic(data, ['gender', 'pet'], ax=ax[3, 2], title='both keys', axes_label=False)
mosaic(data, ['pet', 'gender'], ax=ax[3, 3], title='keys inverted', axes_label=False)
pylab.suptitle('testing data conversion (plot 1 of 4)')
#pylab.show()
@dec.skipif(not have_matplotlib)
def test_mosaic_simple():
# display a simple plot of 4 categories of data, splitted in four
# levels with increasing size for each group
# creation of the levels
key_set = (['male', 'female'], ['old', 'adult', 'young'],
['worker', 'unemployed'], ['healty', 'ill'])
# the cartesian product of all the categories is
# the complete set of categories
keys = list(product(*key_set))
data = OrderedDict(zip(keys, range(1, 1 + len(keys))))
# which colours should I use for the various categories?
# put it into a dict
props = {}
#males and females in blue and red
props[('male',)] = {'color': 'b'}
props[('female',)] = {'color': 'r'}
# all the groups corresponding to ill groups have a different color
for key in keys:
if 'ill' in key:
if 'male' in key:
props[key] = {'color': 'BlueViolet' , 'hatch': '+'}
else:
props[key] = {'color': 'Crimson' , 'hatch': '+'}
# mosaic of the data, with given gaps and colors
mosaic(data, gap=0.05, properties=props, axes_label=False)
pylab.suptitle('syntetic data, 4 categories (plot 2 of 4)')
#pylab.show()
@dec.skipif(not have_matplotlib or pandas_old)
def test_mosaic():
# make the same analysis on a known dataset
# load the data and clean it a bit
affairs = datasets.fair.load_pandas()
datas = affairs.exog
# any time greater than 0 is cheating
datas['cheated'] = affairs.endog > 0
# sort by the marriage quality and give meaningful name
# [rate_marriage, age, yrs_married, children,
# religious, educ, occupation, occupation_husb]
datas = datas.sort(['rate_marriage', 'religious'])
num_to_desc = {1: 'awful', 2: 'bad', 3: 'intermediate',
4: 'good', 5: 'wonderful'}
datas['rate_marriage'] = datas['rate_marriage'].map(num_to_desc)
num_to_faith = {1: 'non religious', 2: 'poorly religious', 3: 'religious',
4: 'very religious'}
datas['religious'] = datas['religious'].map(num_to_faith)
num_to_cheat = {False: 'faithful', True: 'cheated'}
datas['cheated'] = datas['cheated'].map(num_to_cheat)
# finished cleaning
fig, ax = pylab.subplots(2, 2)
mosaic(datas, ['rate_marriage', 'cheated'], ax=ax[0, 0],
title='by marriage happiness')
mosaic(datas, ['religious', 'cheated'], ax=ax[0, 1],
title='by religiosity')
mosaic(datas, ['rate_marriage', 'religious', 'cheated'], ax=ax[1, 0],
title='by both', labelizer=lambda k:'')
ax[1, 0].set_xlabel('marriage rating')
ax[1, 0].set_ylabel('religion status')
mosaic(datas, ['religious', 'rate_marriage'], ax=ax[1, 1],
title='inter-dependence', axes_label=False)
pylab.suptitle("extramarital affairs (plot 3 of 4)")
#pylab.show()
@dec.skipif(not have_matplotlib)
def test_mosaic_very_complex():
# make a scattermatrix of mosaic plots to show the correlations between
# each pair of variable in a dataset. Could be easily converted into a
# new function that does this automatically based on the type of data
key_name = ['gender', 'age', 'health', 'work']
key_base = (['male', 'female'], ['old', 'young'],
['healty', 'ill'], ['work', 'unemployed'])
keys = list(product(*key_base))
data = OrderedDict(zip(keys, range(1, 1 + len(keys))))
props = {}
props[('male', 'old')] = {'color': 'r'}
props[('female',)] = {'color': 'pink'}
L = len(key_base)
fig, axes = pylab.subplots(L, L)
for i in range(L):
for j in range(L):
m = set(range(L)).difference(set((i, j)))
if i == j:
axes[i, i].text(0.5, 0.5, key_name[i],
ha='center', va='center')
axes[i, i].set_xticks([])
axes[i, i].set_xticklabels([])
axes[i, i].set_yticks([])
axes[i, i].set_yticklabels([])
else:
ji = max(i, j)
ij = min(i, j)
temp_data = OrderedDict([((k[ij], k[ji]) + tuple(k[r] for r in m), v)
for k, v in iteritems(data)])
keys = list(iterkeys(temp_data))
for k in keys:
value = _reduce_dict(temp_data, k[:2])
temp_data[k[:2]] = value
del temp_data[k]
mosaic(temp_data, ax=axes[i, j], axes_label=False,
properties=props, gap=0.05, horizontal=i > j)
pylab.suptitle('old males should look bright red, (plot 4 of 4)')
#pylab.show()
@dec.skipif(not have_matplotlib)
def test_axes_labeling():
from numpy.random import rand
key_set = (['male', 'female'], ['old', 'adult', 'young'],
['worker', 'unemployed'], ['yes', 'no'])
# the cartesian product of all the categories is
# the complete set of categories
keys = list(product(*key_set))
data = OrderedDict(zip(keys, rand(len(keys))))
lab = lambda k: ''.join(s[0] for s in k)
fig, (ax1, ax2) = pylab.subplots(1, 2, figsize=(16, 8))
mosaic(data, ax=ax1, labelizer=lab, horizontal=True, label_rotation=45)
mosaic(data, ax=ax2, labelizer=lab, horizontal=False,
label_rotation=[0, 45, 90, 0])
#fig.tight_layout()
fig.suptitle("correct alignment of the axes labels")
#pylab.show()
@dec.skipif(not have_matplotlib or pandas_old)
def test_mosaic_empty_cells():
# SMOKE test see #2286
import pandas as pd
mydata = pd.DataFrame({'id2': {64: 'Angelica',
65: 'DXW_UID', 66: 'casuid01',
67: 'casuid01', 68: 'EC93_uid',
69: 'EC93_uid', 70: 'EC93_uid',
60: 'DXW_UID', 61: 'AtmosFox',
62: 'DXW_UID', 63: 'DXW_UID'},
'id1': {64: 'TGP',
65: 'Retention01', 66: 'default',
67: 'default', 68: 'Musa_EC_9_3',
69: 'Musa_EC_9_3', 70: 'Musa_EC_9_3',
60: 'default', 61: 'default',
62: 'default', 63: 'default'}})
ct = pd.crosstab(mydata.id1, mydata.id2)
fig, vals = mosaic(ct.T.unstack())
fig, vals = mosaic(mydata, ['id1','id2'])
eq = lambda x, y: assert_(np.allclose(x, y))
def test_recursive_split():
keys = list(product('mf'))
data = OrderedDict(zip(keys, [1] * len(keys)))
res = _hierarchical_split(data, gap=0)
assert_(list(iterkeys(res)) == keys)
res[('m',)] = (0.0, 0.0, 0.5, 1.0)
res[('f',)] = (0.5, 0.0, 0.5, 1.0)
keys = list(product('mf', 'yao'))
data = OrderedDict(zip(keys, [1] * len(keys)))
res = _hierarchical_split(data, gap=0)
assert_(list(iterkeys(res)) == keys)
res[('m', 'y')] = (0.0, 0.0, 0.5, 1 / 3)
res[('m', 'a')] = (0.0, 1 / 3, 0.5, 1 / 3)
res[('m', 'o')] = (0.0, 2 / 3, 0.5, 1 / 3)
res[('f', 'y')] = (0.5, 0.0, 0.5, 1 / 3)
res[('f', 'a')] = (0.5, 1 / 3, 0.5, 1 / 3)
res[('f', 'o')] = (0.5, 2 / 3, 0.5, 1 / 3)
def test__reduce_dict():
data = OrderedDict(zip(list(product('mf', 'oy', 'wn')), [1] * 8))
eq(_reduce_dict(data, ('m',)), 4)
eq(_reduce_dict(data, ('m', 'o')), 2)
eq(_reduce_dict(data, ('m', 'o', 'w')), 1)
data = OrderedDict(zip(list(product('mf', 'oy', 'wn')), lrange(8)))
eq(_reduce_dict(data, ('m',)), 6)
eq(_reduce_dict(data, ('m', 'o')), 1)
eq(_reduce_dict(data, ('m', 'o', 'w')), 0)
def test__key_splitting():
# subdivide starting with an empty tuple
base_rect = {tuple(): (0, 0, 1, 1)}
res = _key_splitting(base_rect, ['a', 'b'], [1, 1], tuple(), True, 0)
assert_(list(iterkeys(res)) == [('a',), ('b',)])
eq(res[('a',)], (0, 0, 0.5, 1))
eq(res[('b',)], (0.5, 0, 0.5, 1))
# subdivide a in two sublevel
res_bis = _key_splitting(res, ['c', 'd'], [1, 1], ('a',), False, 0)
assert_(list(iterkeys(res_bis)) == [('a', 'c'), ('a', 'd'), ('b',)])
eq(res_bis[('a', 'c')], (0.0, 0.0, 0.5, 0.5))
eq(res_bis[('a', 'd')], (0.0, 0.5, 0.5, 0.5))
eq(res_bis[('b',)], (0.5, 0, 0.5, 1))
# starting with a non empty tuple and uneven distribution
base_rect = {('total',): (0, 0, 1, 1)}
res = _key_splitting(base_rect, ['a', 'b'], [1, 2], ('total',), True, 0)
assert_(list(iterkeys(res)) == [('total',) + (e,) for e in ['a', 'b']])
eq(res[('total', 'a')], (0, 0, 1 / 3, 1))
eq(res[('total', 'b')], (1 / 3, 0, 2 / 3, 1))
def test_proportion_normalization():
# extremes should give the whole set, as well
# as if 0 is inserted
eq(_normalize_split(0.), [0.0, 0.0, 1.0])
eq(_normalize_split(1.), [0.0, 1.0, 1.0])
eq(_normalize_split(2.), [0.0, 1.0, 1.0])
# negative values should raise ValueError
assert_raises(ValueError, _normalize_split, -1)
assert_raises(ValueError, _normalize_split, [1., -1])
assert_raises(ValueError, _normalize_split, [1., -1, 0.])
# if everything is zero it will complain
assert_raises(ValueError, _normalize_split, [0.])
assert_raises(ValueError, _normalize_split, [0., 0.])
# one-element array should return the whole interval
eq(_normalize_split([0.5]), [0.0, 1.0])
eq(_normalize_split([1.]), [0.0, 1.0])
eq(_normalize_split([2.]), [0.0, 1.0])
# simple division should give two pieces
for x in [0.3, 0.5, 0.9]:
eq(_normalize_split(x), [0., x, 1.0])
# multiple division should split as the sum of the components
for x, y in [(0.25, 0.5), (0.1, 0.8), (10., 30.)]:
eq(_normalize_split([x, y]), [0., x / (x + y), 1.0])
for x, y, z in [(1., 1., 1.), (0.1, 0.5, 0.7), (10., 30., 40)]:
eq(_normalize_split(
[x, y, z]), [0., x / (x + y + z), (x + y) / (x + y + z), 1.0])
def test_false_split():
# if you ask it to be divided in only one piece, just return the original
# one
pure_square = [0., 0., 1., 1.]
conf_h = dict(proportion=[1], gap=0.0, horizontal=True)
conf_v = dict(proportion=[1], gap=0.0, horizontal=False)
eq(_split_rect(*pure_square, **conf_h), pure_square)
eq(_split_rect(*pure_square, **conf_v), pure_square)
conf_h = dict(proportion=[1], gap=0.5, horizontal=True)
conf_v = dict(proportion=[1], gap=0.5, horizontal=False)
eq(_split_rect(*pure_square, **conf_h), pure_square)
eq(_split_rect(*pure_square, **conf_v), pure_square)
# identity on a void rectangle should not give anything strange
null_square = [0., 0., 0., 0.]
conf = dict(proportion=[1], gap=0.0, horizontal=True)
eq(_split_rect(*null_square, **conf), null_square)
conf = dict(proportion=[1], gap=1.0, horizontal=True)
eq(_split_rect(*null_square, **conf), null_square)
# splitting a negative rectangle should raise error
neg_square = [0., 0., -1., 0.]
conf = dict(proportion=[1], gap=0.0, horizontal=True)
assert_raises(ValueError, _split_rect, *neg_square, **conf)
conf = dict(proportion=[1, 1], gap=0.0, horizontal=True)
assert_raises(ValueError, _split_rect, *neg_square, **conf)
conf = dict(proportion=[1], gap=0.5, horizontal=True)
assert_raises(ValueError, _split_rect, *neg_square, **conf)
conf = dict(proportion=[1, 1], gap=0.5, horizontal=True)
assert_raises(ValueError, _split_rect, *neg_square, **conf)
def test_rect_pure_split():
pure_square = [0., 0., 1., 1.]
# division in two equal pieces from the perfect square
h_2split = [(0.0, 0.0, 0.5, 1.0), (0.5, 0.0, 0.5, 1.0)]
conf_h = dict(proportion=[1, 1], gap=0.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), h_2split)
v_2split = [(0.0, 0.0, 1.0, 0.5), (0.0, 0.5, 1.0, 0.5)]
conf_v = dict(proportion=[1, 1], gap=0.0, horizontal=False)
eq(_split_rect(*pure_square, **conf_v), v_2split)
# division in two non-equal pieces from the perfect square
h_2split = [(0.0, 0.0, 1 / 3, 1.0), (1 / 3, 0.0, 2 / 3, 1.0)]
conf_h = dict(proportion=[1, 2], gap=0.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), h_2split)
v_2split = [(0.0, 0.0, 1.0, 1 / 3), (0.0, 1 / 3, 1.0, 2 / 3)]
conf_v = dict(proportion=[1, 2], gap=0.0, horizontal=False)
eq(_split_rect(*pure_square, **conf_v), v_2split)
# division in three equal pieces from the perfect square
h_2split = [(0.0, 0.0, 1 / 3, 1.0), (1 / 3, 0.0, 1 / 3, 1.0), (2 / 3, 0.0,
1 / 3, 1.0)]
conf_h = dict(proportion=[1, 1, 1], gap=0.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), h_2split)
v_2split = [(0.0, 0.0, 1.0, 1 / 3), (0.0, 1 / 3, 1.0, 1 / 3), (0.0, 2 / 3,
1.0, 1 / 3)]
conf_v = dict(proportion=[1, 1, 1], gap=0.0, horizontal=False)
eq(_split_rect(*pure_square, **conf_v), v_2split)
# division in three non-equal pieces from the perfect square
h_2split = [(0.0, 0.0, 1 / 4, 1.0), (1 / 4, 0.0, 1 / 2, 1.0), (3 / 4, 0.0,
1 / 4, 1.0)]
conf_h = dict(proportion=[1, 2, 1], gap=0.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), h_2split)
v_2split = [(0.0, 0.0, 1.0, 1 / 4), (0.0, 1 / 4, 1.0, 1 / 2), (0.0, 3 / 4,
1.0, 1 / 4)]
conf_v = dict(proportion=[1, 2, 1], gap=0.0, horizontal=False)
eq(_split_rect(*pure_square, **conf_v), v_2split)
# splitting on a void rectangle should give multiple void
null_square = [0., 0., 0., 0.]
conf = dict(proportion=[1, 1], gap=0.0, horizontal=True)
eq(_split_rect(*null_square, **conf), [null_square, null_square])
conf = dict(proportion=[1, 2], gap=1.0, horizontal=True)
eq(_split_rect(*null_square, **conf), [null_square, null_square])
def test_rect_deformed_split():
non_pure_square = [1., -1., 1., 0.5]
# division in two equal pieces from the perfect square
h_2split = [(1.0, -1.0, 0.5, 0.5), (1.5, -1.0, 0.5, 0.5)]
conf_h = dict(proportion=[1, 1], gap=0.0, horizontal=True)
eq(_split_rect(*non_pure_square, **conf_h), h_2split)
v_2split = [(1.0, -1.0, 1.0, 0.25), (1.0, -0.75, 1.0, 0.25)]
conf_v = dict(proportion=[1, 1], gap=0.0, horizontal=False)
eq(_split_rect(*non_pure_square, **conf_v), v_2split)
# division in two non-equal pieces from the perfect square
h_2split = [(1.0, -1.0, 1 / 3, 0.5), (1 + 1 / 3, -1.0, 2 / 3, 0.5)]
conf_h = dict(proportion=[1, 2], gap=0.0, horizontal=True)
eq(_split_rect(*non_pure_square, **conf_h), h_2split)
v_2split = [(1.0, -1.0, 1.0, 1 / 6), (1.0, 1 / 6 - 1, 1.0, 2 / 6)]
conf_v = dict(proportion=[1, 2], gap=0.0, horizontal=False)
eq(_split_rect(*non_pure_square, **conf_v), v_2split)
def test_gap_split():
pure_square = [0., 0., 1., 1.]
# null split
conf_h = dict(proportion=[1], gap=1.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), pure_square)
# equal split
h_2split = [(0.0, 0.0, 0.25, 1.0), (0.75, 0.0, 0.25, 1.0)]
conf_h = dict(proportion=[1, 1], gap=1.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), h_2split)
# disequal split
h_2split = [(0.0, 0.0, 1 / 6, 1.0), (0.5 + 1 / 6, 0.0, 1 / 3, 1.0)]
conf_h = dict(proportion=[1, 2], gap=1.0, horizontal=True)
eq(_split_rect(*pure_square, **conf_h), h_2split)
def test_default_arg_index():
# 2116
import pandas as pd
df = pd.DataFrame({'size' : ['small', 'large', 'large', 'small', 'large',
'small'],
'length' : ['long', 'short', 'short', 'long', 'long',
'short']})
assert_raises(ValueError, mosaic, data=df, title='foobar')
if __name__ == '__main__':
run_module_suite()
| bsd-3-clause |
mengli/MachineLearning | kaggle/TalkingData/talking_data.py | 2 | 12465 | import pandas as pd
import time
import numpy as np
import lightgbm as lgb
import gc
import os
def do_count(df, group_cols, agg_name, agg_type='uint32', show_max=False, show_agg=True):
if show_agg:
print("Aggregating by ", group_cols, '...')
gp = df[group_cols][group_cols].groupby(group_cols).size().rename(agg_name).to_frame().reset_index()
df = df.merge(gp, on=group_cols, how='left')
del gp
if show_max:
print(agg_name + " max value = ", df[agg_name].max())
df[agg_name] = df[agg_name].astype(agg_type)
gc.collect()
return (df)
def do_countuniq(df, group_cols, counted, agg_name, agg_type='uint32', show_max=False, show_agg=True):
if show_agg:
print("Counting unqiue ", counted, " by ", group_cols, '...')
gp = df[group_cols + [counted]].groupby(group_cols)[counted].nunique().reset_index().rename(
columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
if show_max:
print(agg_name + " max value = ", df[agg_name].max())
df[agg_name] = df[agg_name].astype(agg_type)
gc.collect()
return (df)
def do_cumcount(df, group_cols, counted, agg_name, agg_type='uint32', show_max=False, show_agg=True):
if show_agg:
print("Cumulative count by ", group_cols, '...')
gp = df[group_cols + [counted]].groupby(group_cols)[counted].cumcount()
df[agg_name] = gp.values
del gp
if show_max:
print(agg_name + " max value = ", df[agg_name].max())
df[agg_name] = df[agg_name].astype(agg_type)
gc.collect()
return (df)
def do_mean(df, group_cols, counted, agg_name, agg_type='float32', show_max=False, show_agg=True):
if show_agg:
print("Calculating mean of ", counted, " by ", group_cols, '...')
gp = df[group_cols + [counted]].groupby(group_cols)[counted].mean().reset_index().rename(
columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
if show_max:
print(agg_name + " max value = ", df[agg_name].max())
df[agg_name] = df[agg_name].astype(agg_type)
gc.collect()
return (df)
def do_var(df, group_cols, counted, agg_name, agg_type='float32', show_max=False, show_agg=True):
if show_agg:
print("Calculating variance of ", counted, " by ", group_cols, '...')
gp = df[group_cols + [counted]].groupby(group_cols)[counted].var().reset_index().rename(columns={counted: agg_name})
df = df.merge(gp, on=group_cols, how='left')
del gp
if show_max:
print(agg_name + " max value = ", df[agg_name].max())
df[agg_name] = df[agg_name].astype(agg_type)
gc.collect()
return (df)
def lgb_modelfit_nocv(params, dtrain, dvalid, predictors, target='target', objective='binary', metrics='auc',
feval=None, early_stopping_rounds=20, num_boost_round=3000, verbose_eval=10,
categorical_features=None):
lgb_params = {
'boosting_type': 'gbdt',
'objective': objective,
'metric': metrics,
'learning_rate': 0.2,
'num_leaves': 31, # we should let it be smaller than 2^(max_depth)
'max_depth': -1, # -1 means no limit
'min_child_samples': 20, # Minimum number of data need in a child(min_data_in_leaf)
'max_bin': 255, # Number of bucketed bin for feature values
'subsample': 0.6, # Subsample ratio of the training instance.
'subsample_freq': 0, # frequence of subsample, <=0 means no enable
'colsample_bytree': 0.3, # Subsample ratio of columns when constructing each tree.
'min_child_weight': 5, # Minimum sum of instance weight(hessian) needed in a child(leaf)
'subsample_for_bin': 200000, # Number of samples for constructing bin
'min_split_gain': 0, # lambda_l1, lambda_l2 and min_gain_to_split to regularization
'reg_alpha': 0, # L1 regularization term on weights
'reg_lambda': 0, # L2 regularization term on weights
'nthread': 4,
'verbose': 0,
'metric': metrics
}
lgb_params.update(params)
print("preparing validation datasets")
xgtrain = lgb.Dataset(dtrain[predictors].values, label=dtrain[target].values,
feature_name=predictors,
categorical_feature=categorical_features
)
xgvalid = lgb.Dataset(dvalid[predictors].values, label=dvalid[target].values,
feature_name=predictors,
categorical_feature=categorical_features
)
evals_results = {}
bst1 = lgb.train(lgb_params,
xgtrain,
valid_sets=[xgtrain, xgvalid],
valid_names=['train', 'valid'],
evals_result=evals_results,
num_boost_round=num_boost_round,
early_stopping_rounds=early_stopping_rounds,
verbose_eval=10,
feval=feval)
print("\nModel Report")
print("bst1.best_iteration: ", bst1.best_iteration)
print(metrics + ":", evals_results['valid'][metrics][bst1.best_iteration - 1])
return (bst1, bst1.best_iteration)
def DO(frm, to, fileno):
dtypes = {
'ip': 'uint32',
'app': 'uint16',
'device': 'uint16',
'os': 'uint16',
'channel': 'uint16',
'is_attributed': 'uint8',
'click_id': 'uint32',
}
print('loading train data...', frm, to)
train_df = pd.read_csv("./train.csv", parse_dates=['click_time'], skiprows=range(1, frm), nrows=to - frm,
dtype=dtypes,
usecols=['ip', 'app', 'device', 'os', 'channel', 'click_time', 'is_attributed'])
print('loading test data...')
test_df = pd.read_csv("./test.csv", parse_dates=['click_time'], dtype=dtypes,
usecols=['ip', 'app', 'device', 'os', 'channel', 'click_time', 'click_id'])
len_train = len(train_df)
train_df = train_df.append(test_df)
del test_df
gc.collect()
print('Extracting new features...')
train_df['hour'] = pd.to_datetime(train_df.click_time).dt.hour.astype('uint8')
train_df['day'] = pd.to_datetime(train_df.click_time).dt.day.astype('uint8')
gc.collect()
train_df = do_countuniq(train_df, ['ip'], 'channel', 'X0', 'uint8', show_max=True)
gc.collect()
train_df = do_cumcount(train_df, ['ip', 'device', 'os'], 'app', 'X1', show_max=True)
gc.collect()
train_df = do_countuniq(train_df, ['ip', 'day'], 'hour', 'X2', 'uint8', show_max=True)
gc.collect()
train_df = do_countuniq(train_df, ['ip'], 'app', 'X3', 'uint8', show_max=True)
gc.collect()
train_df = do_countuniq(train_df, ['ip', 'app'], 'os', 'X4', 'uint8', show_max=True)
gc.collect()
train_df = do_countuniq(train_df, ['ip'], 'device', 'X5', 'uint16', show_max=True)
gc.collect()
train_df = do_countuniq(train_df, ['app'], 'channel', 'X6', show_max=True)
gc.collect()
train_df = do_cumcount(train_df, ['ip'], 'os', 'X7', show_max=True)
gc.collect()
train_df = do_countuniq(train_df, ['ip', 'device', 'os'], 'app', 'X8', show_max=True)
gc.collect()
train_df = do_count(train_df, ['ip', 'day', 'hour'], 'ip_tcount', show_max=True)
gc.collect()
train_df = do_count(train_df, ['ip', 'app'], 'ip_app_count', show_max=True)
gc.collect()
train_df = do_count(train_df, ['ip', 'app', 'os'], 'ip_app_os_count', 'uint16', show_max=True)
gc.collect()
train_df = do_var(train_df, ['ip', 'day', 'channel'], 'hour', 'ip_tchan_count', show_max=True)
gc.collect()
train_df = do_var(train_df, ['ip', 'app', 'os'], 'hour', 'ip_app_os_var', show_max=True)
gc.collect()
train_df = do_var(train_df, ['ip', 'app', 'channel'], 'day', 'ip_app_channel_var_day', show_max=True)
gc.collect()
train_df = do_mean(train_df, ['ip', 'app', 'channel'], 'hour', 'ip_app_channel_mean_hour', show_max=True)
gc.collect()
print('doing nextClick')
predictors = []
new_feature = 'nextClick'
filename = 'nextClick_%d_%d.csv' % (frm, to)
if os.path.exists(filename):
print('loading from save file')
QQ = pd.read_csv(filename).values
else:
D = 2 ** 26
train_df['category'] = (train_df['ip'].astype(str) + "_" + train_df['app'].astype(str) + "_" + train_df[
'device'].astype(str) + "_" + train_df['os'].astype(str)).apply(hash) % D
click_buffer = np.full(D, 3000000000, dtype=np.uint32)
train_df['epochtime'] = train_df['click_time'].astype(np.int64) // 10 ** 9
next_clicks = []
for category, t in zip(reversed(train_df['category'].values), reversed(train_df['epochtime'].values)):
next_clicks.append(click_buffer[category] - t)
click_buffer[category] = t
del (click_buffer)
QQ = list(reversed(next_clicks))
print('saving')
pd.DataFrame(QQ).to_csv(filename, index=False)
train_df.drop(['epochtime', 'category', 'click_time'], axis=1, inplace=True)
train_df[new_feature] = pd.Series(QQ).astype('float32')
predictors.append(new_feature)
train_df[new_feature + '_shift'] = train_df[new_feature].shift(+1).values
predictors.append(new_feature + '_shift')
del QQ
gc.collect()
print("vars and data type: ")
train_df.info()
train_df['ip_tcount'] = train_df['ip_tcount'].astype('uint16')
train_df['ip_app_count'] = train_df['ip_app_count'].astype('uint16')
train_df['ip_app_os_count'] = train_df['ip_app_os_count'].astype('uint16')
target = 'is_attributed'
predictors.extend(['app', 'device', 'os', 'channel', 'hour', 'day',
'ip_tcount', 'ip_tchan_count', 'ip_app_count',
'ip_app_os_count', 'ip_app_os_var',
'ip_app_channel_var_day', 'ip_app_channel_mean_hour',
'X0', 'X1', 'X2', 'X3', 'X4', 'X5', 'X6', 'X7', 'X8'])
categorical = ['app', 'device', 'os', 'channel', 'hour', 'day']
print('predictors', predictors)
test_df = train_df[len_train:]
val_df = train_df[(len_train - val_size):len_train]
train_df = train_df[:(len_train - val_size)]
print("train size: ", len(train_df))
print("valid size: ", len(val_df))
print("test size : ", len(test_df))
sub = pd.DataFrame()
sub['click_id'] = test_df['click_id'].astype('int')
gc.collect()
print("Training...")
start_time = time.time()
params = {
'learning_rate': 0.20,
'num_leaves': 7, # 2^max_depth - 1
'max_depth': 3, # -1 means no limit
'min_child_samples': 100, # Minimum number of data need in a child(min_data_in_leaf)
'max_bin': 100, # Number of bucketed bin for feature values
'subsample': 0.7, # Subsample ratio of the training instance.
'subsample_freq': 1, # frequence of subsample, <=0 means no enable
'colsample_bytree': 0.9, # Subsample ratio of columns when constructing each tree.
'min_child_weight': 0, # Minimum sum of instance weight(hessian) needed in a child(leaf)
'scale_pos_weight': 200 # because training data is extremely unbalanced
}
(bst, best_iteration) = lgb_modelfit_nocv(params,
train_df,
val_df,
predictors,
target,
objective='binary',
metrics='auc',
early_stopping_rounds=30,
verbose_eval=True,
num_boost_round=1000,
categorical_features=categorical)
print('[{}]: model training time'.format(time.time() - start_time))
del train_df
del val_df
gc.collect()
print("Predicting...")
sub['is_attributed'] = bst.predict(test_df[predictors], num_iteration=best_iteration)
print("writing...")
sub.to_csv('sub_it%d.csv' % (fileno), index=False, float_format='%.9f')
print("done...")
return sub
nrows = 184903891 - 1
nchunk = 25000000
val_size = 2500000
frm = nrows - 75000000
to = frm + nchunk
sub = DO(frm, to, 0)
| apache-2.0 |
annayqho/TheCannon | code/lamost/xcalib_5labels/paper_plots/plot_survey_coverage_unknown.py | 1 | 5470 | #!/usr/bin/env python
import numpy as np
import healpy as hp
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib import rc
from matplotlib import rcParams
from matplotlib.colors import LogNorm
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
import pyfits
# import the data
hdulist = pyfits.open("../make_lamost_catalog/lamost_catalog_full.fits")
tbdata = hdulist[1].data
# cols = hdulist[1].columns
# cols.names
ra_lamost = tbdata.field('ra')
dec_lamost = tbdata.field('dec')
am_lamost = tbdata.field("cannon_a_k")
rmag_lamost = tbdata.field("mag3")
hdulist.close()
hdulist = pyfits.open("/home/annaho/aida41040/annaho/TheCannon/examples/example_DR12/allStar-v603.fits")
tbdata = hdulist[1].data
ra_apogee_all = tbdata['RA']
dec_apogee_all = tbdata['DEC']
am_apogee_all = tbdata['PARAM_ALPHA_M']
am_apogee_all = tbdata['AK_WISE']
good_coords = np.logical_and(ra_apogee_all > -90, dec_apogee_all > -90)
good = np.logical_and(good_coords, am_apogee_all > -90)
ra_apogee = ra_apogee_all[good]
dec_apogee = dec_apogee_all[good]
am_apogee = am_apogee_all[good]
hdulist.close()
ra_both = np.hstack((ra_apogee, ra_lamost))
dec_both = np.hstack((dec_apogee, dec_lamost))
am_all = np.hstack((am_apogee, am_lamost))
# create a RA and Dec grid
ra_all = []
dec_all = []
for ra in np.arange(0, 360, 0.5):
for dec in np.arange(-90, 90, 0.5):
ra_all.append(ra)
dec_all.append(dec)
ra = np.array(ra_all)
dec = np.array(dec_all)
# convert RA and Dec to phi and theta coordinates
def toPhiTheta(ra, dec):
phi = ra * np.pi/180.
theta = (90.0 - dec) * np.pi / 180.
return phi, theta
phi, theta = toPhiTheta(ra, dec)
phi_lamost, theta_lamost = toPhiTheta(ra_lamost, dec_lamost)
phi_apogee, theta_apogee = toPhiTheta(ra_apogee, dec_apogee)
phi_all, theta_all = toPhiTheta(ra_both, dec_both)
# to just plot all points, do
#hp.visufunc.projplot(theta, phi, 'bo')
#hp.visufunc.projplot(theta_lamost, phi_lamost, 'bo')
#hp.visufunc.graticule() # just the bare background w/ lines
# more examples are here
# https://healpy.readthedocs.org/en/latest/generated/healpy.visufunc.projplot.html#healpy.visufunc.projplot
## to plot a 2D histogram in the Mollweide projection
# define the HEALPIX level
# NSIDE = 32 # defines the resolution of the map
NSIDE = 128
# find the pixel ID for each point
# pix = hp.pixelfunc.ang2pix(NSIDE, theta, phi)
pix_lamost = hp.pixelfunc.ang2pix(NSIDE, theta_lamost, phi_lamost)
pix_apogee = hp.pixelfunc.ang2pix(NSIDE, theta_apogee, phi_apogee)
pix_all = hp.pixelfunc.ang2pix(NSIDE, theta_all, phi_all)
# pix is in the order of ra and dec
# prepare the map array
m_lamost = hp.ma(np.zeros(hp.nside2npix(NSIDE), dtype='float'))
mask_lamost = np.zeros(hp.nside2npix(NSIDE), dtype='bool')
for pix_val in np.unique(pix_lamost):
choose = np.where(pix_lamost==pix_val)[0]
if len(choose) == 1:
#m_lamost[pix_val] = rmag_lamost[choose[0]]
m_lamost[pix_val] = am_lamost[choose[0]]
else:
#m_lamost[pix_val] = np.median(rmag_lamost[choose])
m_lamost[pix_val] = np.median(am_lamost[choose])
mask_lamost[np.setdiff1d(np.arange(len(m_lamost)), pix_lamost)] = 1
m_lamost.mask = mask_lamost
m_apogee= hp.ma(np.zeros(hp.nside2npix(NSIDE), dtype='float'))
mask_apogee= np.zeros(hp.nside2npix(NSIDE), dtype='bool')
for pix_val in np.unique(pix_apogee):
choose = np.where(pix_apogee==pix_val)[0]
if len(choose) == 1:
m_apogee[pix_val] = am_apogee[choose[0]]
else:
m_apogee[pix_val] = np.median(am_apogee[choose])
mask_apogee[np.setdiff1d(np.arange(len(m_apogee)), pix_apogee)] = 1
m_apogee.mask = mask_apogee
m_all = hp.ma(np.zeros(hp.nside2npix(NSIDE), dtype='float'))
mask_all= np.zeros(hp.nside2npix(NSIDE), dtype='bool')
for pix_val in np.unique(pix_all):
choose = np.where(pix_all==pix_val)[0]
if len(choose) == 1:
m_all[pix_val] = am_all[choose[0]]
else:
m_all[pix_val] = np.median(am_all[choose])
mask_all[np.setdiff1d(np.arange(len(m_all)), pix_all)] = 1
m_all.mask = mask_all
# perceptually uniform: inferno, viridis, plasma, magma
cmap=cm.magma
cmap.set_under('w')
# composite map
# plot map ('C' means the input coordinates were in the equatorial system)
rcParams.update({'font.size':16})
#hp.visufunc.mollview(m_apogee, coord=['C','G'], rot=(150, 0, 0), flip='astro',
# notext=True, title=r'$\alpha$/M for APOGEE DR12', cbar=True,
# norm=None, min=-0.07, max=0.3, cmap=cmap, unit = r'$\alpha$/M [dex]')
#hp.visufunc.mollview(m_lamost, coord=['C','G'], rot=(150, 0, 0), flip='astro',
# notext=True, title=r'$\alpha$/M for 500,000 LAMOST giants', cbar=True,
# norm=None, min=-0.07, max=0.3, cmap=cmap, unit = r'$\alpha$/M [dex]')
#notext=True, title="r-band magnitude for 500,000 LAMOST giants", cbar=True,
#norm=None, min=11, max=17, cmap=cmap, unit = r"r-band magnitude [mag]")
hp.visufunc.mollview(m_all, coord=['C','G'], rot=(150, 0, 0), flip='astro',
notext=True, title=r'$\alpha$/M for APOGEE DR12 + 500,000 LAMOST giants', cbar=True,
norm=None, min=0.00, max=0.4, cmap=cmap, unit = r'$\alpha$/M [dex]')
hp.visufunc.graticule()
#plt.show()
plt.savefig("full_ak_map.png")
#plt.savefig("apogee_am_map.png")
#plt.savefig("lamost_am_map_magma.png")
#plt.savefig("lamost_rmag_map.png")
| mit |
sonnyhu/scipy | scipy/interpolate/tests/test_rbf.py | 41 | 4367 | #!/usr/bin/env python
# Created by John Travers, Robert Hetland, 2007
""" Test functions for rbf module """
from __future__ import division, print_function, absolute_import
import numpy as np
from numpy.testing import (assert_, assert_array_almost_equal,
assert_almost_equal, run_module_suite)
from numpy import linspace, sin, random, exp, allclose
from scipy.interpolate.rbf import Rbf
FUNCTIONS = ('multiquadric', 'inverse multiquadric', 'gaussian',
'cubic', 'quintic', 'thin-plate', 'linear')
def check_rbf1d_interpolation(function):
# Check that the Rbf function interpolates through the nodes (1D)
x = linspace(0,10,9)
y = sin(x)
rbf = Rbf(x, y, function=function)
yi = rbf(x)
assert_array_almost_equal(y, yi)
assert_almost_equal(rbf(float(x[0])), y[0])
def check_rbf2d_interpolation(function):
# Check that the Rbf function interpolates through the nodes (2D).
x = random.rand(50,1)*4-2
y = random.rand(50,1)*4-2
z = x*exp(-x**2-1j*y**2)
rbf = Rbf(x, y, z, epsilon=2, function=function)
zi = rbf(x, y)
zi.shape = x.shape
assert_array_almost_equal(z, zi)
def check_rbf3d_interpolation(function):
# Check that the Rbf function interpolates through the nodes (3D).
x = random.rand(50, 1)*4 - 2
y = random.rand(50, 1)*4 - 2
z = random.rand(50, 1)*4 - 2
d = x*exp(-x**2 - y**2)
rbf = Rbf(x, y, z, d, epsilon=2, function=function)
di = rbf(x, y, z)
di.shape = x.shape
assert_array_almost_equal(di, d)
def test_rbf_interpolation():
for function in FUNCTIONS:
yield check_rbf1d_interpolation, function
yield check_rbf2d_interpolation, function
yield check_rbf3d_interpolation, function
def check_rbf1d_regularity(function, atol):
# Check that the Rbf function approximates a smooth function well away
# from the nodes.
x = linspace(0, 10, 9)
y = sin(x)
rbf = Rbf(x, y, function=function)
xi = linspace(0, 10, 100)
yi = rbf(xi)
# import matplotlib.pyplot as plt
# plt.figure()
# plt.plot(x, y, 'o', xi, sin(xi), ':', xi, yi, '-')
# plt.plot(x, y, 'o', xi, yi-sin(xi), ':')
# plt.title(function)
# plt.show()
msg = "abs-diff: %f" % abs(yi - sin(xi)).max()
assert_(allclose(yi, sin(xi), atol=atol), msg)
def test_rbf_regularity():
tolerances = {
'multiquadric': 0.1,
'inverse multiquadric': 0.15,
'gaussian': 0.15,
'cubic': 0.15,
'quintic': 0.1,
'thin-plate': 0.1,
'linear': 0.2
}
for function in FUNCTIONS:
yield check_rbf1d_regularity, function, tolerances.get(function, 1e-2)
def check_rbf1d_stability(function):
# Check that the Rbf function with default epsilon is not subject
# to overshoot. Regression for issue #4523.
#
# Generate some data (fixed random seed hence deterministic)
np.random.seed(1234)
x = np.linspace(0, 10, 50)
z = x + 4.0 * np.random.randn(len(x))
rbf = Rbf(x, z, function=function)
xi = np.linspace(0, 10, 1000)
yi = rbf(xi)
# subtract the linear trend and make sure there no spikes
assert_(np.abs(yi-xi).max() / np.abs(z-x).max() < 1.1)
def test_rbf_stability():
for function in FUNCTIONS:
yield check_rbf1d_stability, function
def test_default_construction():
# Check that the Rbf class can be constructed with the default
# multiquadric basis function. Regression test for ticket #1228.
x = linspace(0,10,9)
y = sin(x)
rbf = Rbf(x, y)
yi = rbf(x)
assert_array_almost_equal(y, yi)
def test_function_is_callable():
# Check that the Rbf class can be constructed with function=callable.
x = linspace(0,10,9)
y = sin(x)
linfunc = lambda x:x
rbf = Rbf(x, y, function=linfunc)
yi = rbf(x)
assert_array_almost_equal(y, yi)
def test_two_arg_function_is_callable():
# Check that the Rbf class can be constructed with a two argument
# function=callable.
def _func(self, r):
return self.epsilon + r
x = linspace(0,10,9)
y = sin(x)
rbf = Rbf(x, y, function=_func)
yi = rbf(x)
assert_array_almost_equal(y, yi)
def test_rbf_epsilon_none():
x = linspace(0, 10, 9)
y = sin(x)
rbf = Rbf(x, y, epsilon=None)
if __name__ == "__main__":
run_module_suite()
| bsd-3-clause |
hipstas/audio-tagging-toolkit | attk/excerpt_class.py | 2 | 4744 | #!/usr/bin/python
import os
import sys, getopt
import time, datetime
import subprocess
#here = os.path.abspath(os.path.dirname(__file__))
#sys.path.append(here)
def excerpt_class(media_path,csv_path,out_dir='',class_to_excerpt=1):
try:
basename=media_path.split('/')[-1][:-4]
except:
return("*** Problem loading basenames ***")
try:
from pydub import AudioSegment
import pandas as pd
import numpy as np
tag_data = pd.read_csv(csv_path,header=None)
except:
print("*** Empty or missing tag CSV. ***")
return("*** Empty or missing tag CSV. ***")
try:
includes_label=False
if len(tag_data.iloc[0])==3:
tag_data.columns=["Start","Class","Duration"]
elif len(tag_data.iloc[0])==4:
tag_data.columns=["Start","Class","Duration","Label"]
includes_label=True
if os.path.exists(media_path):
if media_path.lower()[-4:].lower() in ('.wav','.mp3','.mp4'):
if out_dir=='':
out_dir='/'.join(media_path.split('/')[:-1])+'/'
basename = media_path.split('/')[-1][:-4]
tag_data_relevant=tag_data[tag_data['Class']==class_to_excerpt]
tag_data_relevant.reset_index(inplace=True)
audio_source=True
if media_path.lower()[-4:]=='.mp4': # Creates a temporary WAV
audio_source=False # if input is MP4
temp_filename=media_path.split('/')[-1]+'_temp.wav'
audio_path='/var/tmp/'+temp_filename # Pathname for temp WAV
subprocess.call(['ffmpeg', '-y', '-i', media_path, audio_path]) # '-y' option overwrites existing file if present
else:
audio_path=media_path
song=None
try:
if media_path[-4:].lower()=='.mp3':
song = AudioSegment.from_mp3(audio_path)
else:
song = AudioSegment.from_wav(audio_path)
except:
print("Error loading audio with pyDub.")
return("Error loading audio with pyDub.")
#### Batch extracting specified WAV clips ###
for i in range(len(tag_data_relevant)):
#print("*** Extracting file "+str(i)+" of "+str(len(tag_data_relevant))+". ***\n")
#create_tag_excerpt(tag_data_relevant.iloc[i],audio_path,song,basename,out_dirincludes_label)
row=tag_data_relevant.iloc[i]
start = row['Start']
duration = row['Duration']
start_msec = float(start) * 1000.0
duration_msec = float(duration) * 1000
if includes_label==False:
clip_pathname=os.path.join(out_dir, basename+"_start_"+str(start)[:6]+"_dur_"+str(duration)[:6]+'_class_'+str(class_to_excerpt)+'.wav')
else:
clip_pathname=os.path.join(out_dir+basename+"_start_"+str(start)[:6]+"_dur_"+str(duration)[:6]+'_class_'+str(class_to_excerpt)+'_label_'+str(row['Label'])+'.wav')
if not os.path.exists(clip_pathname):
clip_data = song[start_msec:start_msec+duration_msec]
#clip_data=clip_data.set_channels(1)
clip_data.export(clip_pathname, format="wav")
if audio_source==False:
os.remove(audio_path)
#print("*** All segments extracted! ***")
else: print("\n**Error: Not an acceptable media format. **\n")
else: print("\n**Error: Audio file does not exist. **\n")
except Exception as e: print(e)
def main(argv):
media_path = ''
class_to_excerpt = 1
csv_path=''
out_dir=''
audio_source=True
try:
opts, args = getopt.getopt(argv[1:],"hi:t:e:o:",["ifile="])
except getopt.GetoptError:
print("")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print("")
sys.exit()
elif opt in ("-i", "--ifile"):
media_path = arg
#print(arg)
elif opt in ("-e", "--excerptclass"):
class_to_excerpt = int(arg)
#print(arg)
elif opt in ("-t", "--tags"):
csv_path=arg
#print(csv_path)
elif opt in ("-o", "--outdir"):
out_dir=arg
print("*** Audio output directory: "+out_dir)
excerpt_class(media_path,csv_path,out_dir,class_to_excerpt)
if __name__ == "__main__":
main(sys.argv)
| mit |
JPFrancoia/scikit-learn | sklearn/feature_extraction/tests/test_dict_vectorizer.py | 110 | 3768 | # Authors: Lars Buitinck
# Dan Blanchard <[email protected]>
# License: BSD 3 clause
from random import Random
import numpy as np
import scipy.sparse as sp
from numpy.testing import assert_array_equal
from sklearn.utils.testing import (assert_equal, assert_in,
assert_false, assert_true)
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_selection import SelectKBest, chi2
def test_dictvectorizer():
D = [{"foo": 1, "bar": 3},
{"bar": 4, "baz": 2},
{"bar": 1, "quux": 1, "quuux": 2}]
for sparse in (True, False):
for dtype in (int, np.float32, np.int16):
for sort in (True, False):
for iterable in (True, False):
v = DictVectorizer(sparse=sparse, dtype=dtype, sort=sort)
X = v.fit_transform(iter(D) if iterable else D)
assert_equal(sp.issparse(X), sparse)
assert_equal(X.shape, (3, 5))
assert_equal(X.sum(), 14)
assert_equal(v.inverse_transform(X), D)
if sparse:
# CSR matrices can't be compared for equality
assert_array_equal(X.A, v.transform(iter(D) if iterable
else D).A)
else:
assert_array_equal(X, v.transform(iter(D) if iterable
else D))
if sort:
assert_equal(v.feature_names_,
sorted(v.feature_names_))
def test_feature_selection():
# make two feature dicts with two useful features and a bunch of useless
# ones, in terms of chi2
d1 = dict([("useless%d" % i, 10) for i in range(20)],
useful1=1, useful2=20)
d2 = dict([("useless%d" % i, 10) for i in range(20)],
useful1=20, useful2=1)
for indices in (True, False):
v = DictVectorizer().fit([d1, d2])
X = v.transform([d1, d2])
sel = SelectKBest(chi2, k=2).fit(X, [0, 1])
v.restrict(sel.get_support(indices=indices), indices=indices)
assert_equal(v.get_feature_names(), ["useful1", "useful2"])
def test_one_of_k():
D_in = [{"version": "1", "ham": 2},
{"version": "2", "spam": .3},
{"version=3": True, "spam": -1}]
v = DictVectorizer()
X = v.fit_transform(D_in)
assert_equal(X.shape, (3, 5))
D_out = v.inverse_transform(X)
assert_equal(D_out[0], {"version=1": 1, "ham": 2})
names = v.get_feature_names()
assert_true("version=2" in names)
assert_false("version" in names)
def test_unseen_or_no_features():
D = [{"camelot": 0, "spamalot": 1}]
for sparse in [True, False]:
v = DictVectorizer(sparse=sparse).fit(D)
X = v.transform({"push the pram a lot": 2})
if sparse:
X = X.toarray()
assert_array_equal(X, np.zeros((1, 2)))
X = v.transform({})
if sparse:
X = X.toarray()
assert_array_equal(X, np.zeros((1, 2)))
try:
v.transform([])
except ValueError as e:
assert_in("empty", str(e))
def test_deterministic_vocabulary():
# Generate equal dictionaries with different memory layouts
items = [("%03d" % i, i) for i in range(1000)]
rng = Random(42)
d_sorted = dict(items)
rng.shuffle(items)
d_shuffled = dict(items)
# check that the memory layout does not impact the resulting vocabulary
v_1 = DictVectorizer().fit([d_sorted])
v_2 = DictVectorizer().fit([d_shuffled])
assert_equal(v_1.vocabulary_, v_2.vocabulary_)
| bsd-3-clause |
lanselin/pysal | pysal/weights/tests/test_Distance.py | 5 | 11160 | from pysal.weights import Distance as d
from pysal.weights.util import get_points_array
from pysal.weights import Contiguity as c
from pysal.common import RTOL, ATOL
from pysal.cg.kdtree import KDTree
import numpy as np
import pysal as ps
import unittest as ut
PANDAS_EXTINCT = ps.common.pandas is None
# All instances should test these four methods, and define their own functional
# tests based on common codepaths/estimated weights use cases.
class Distance_Mixin(object):
polygon_path = ps.examples.get_path('columbus.shp')
arc_path = ps.examples.get_path('stl_hom.shp')
points = [(10, 10), (20, 10), (40, 10),
(15, 20), (30, 20), (30, 30)]
euclidean_kdt = ps.cg.KDTree(points, distance_metric='euclidean')
polygon_f = ps.open(polygon_path) # our file handler
poly_centroids = get_points_array(polygon_f) # our iterable
polygon_f.seek(0) #go back to head of file
arc_f = ps.open(arc_path)
ps.cg.sphere.arcdist
arc_points = get_points_array(arc_f)
arc_f.seek(0)
arc_kdt = ps.cg.KDTree(arc_points, distance_metric='Arc',
radius=ps.cg.sphere.RADIUS_EARTH_KM)
cls = object # class constructor
known_wi = None #index of known w entry to compare
known_w = dict() #actual w entry
known_name = known_wi
def setUp(self):
self.__dict__.update({k:v for k,v in Distance_Mixin.__dict__.items()
if not k.startswith('_')})
def test_init(self):
# test vanilla, named
raise NotImplementedError('You need to implement this test '
'before this module will pass')
def test_from_shapefile(self):
# test vanilla, named, sparse
raise NotImplementedError('You need to implement this test '
'before this module will pass')
def test_from_array(self):
# test named, sparse
raise NotImplementedError('You need to implement this test '
'before this module will pass')
def test_from_dataframe(self):
# test named, columnar, defau
raise NotImplementedError('You need to implement this test '
'before this module will pass')
class Test_KNN(ut.TestCase, Distance_Mixin):
def setUp(self):
Distance_Mixin.setUp(self)
self.known_wi0 = 7
self.known_w0 = [3, 6, 12, 11]
self.known_wi1 = 0
self.known_w1 = [2, 1, 3 ,7]
self.known_wi2 = 4
self.known_w2 = [1, 3, 9, 12]
self.known_wi3 = 40
self.known_w3 = [31, 38, 45, 49]
##########################
# Classmethod tests #
##########################
def test_init(self):
w = d.KNN(self.euclidean_kdt, k=2)
self.assertEqual(w.neighbors[0], [1,3])
@ut.skipIf(PANDAS_EXTINCT, 'Missing pandas')
def test_from_dataframe(self):
df = ps.pdio.read_files(self.polygon_path)
w = d.KNN.from_dataframe(df, k=4)
self.assertEqual(w.neighbors[self.known_wi0], self.known_w0)
self.assertEqual(w.neighbors[self.known_wi1], self.known_w1)
def test_from_array(self):
w = d.KNN.from_array(self.poly_centroids, k=4)
self.assertEqual(w.neighbors[self.known_wi0], self.known_w0)
self.assertEqual(w.neighbors[self.known_wi1], self.known_w1)
def test_from_shapefile(self):
w = d.KNN.from_shapefile(self.polygon_path, k=4)
self.assertEqual(w.neighbors[self.known_wi0], self.known_w0)
self.assertEqual(w.neighbors[self.known_wi1], self.known_w1)
##########################
# Function/User tests #
##########################
def test_reweight(self):
w = d.KNN(self.points, k=2)
new_point = [(21,21)]
wnew = w.reweight(k=4, p=1, new_data=new_point, inplace=False)
self.assertEqual(wnew[0], {1: 1.0, 3: 1.0, 4: 1.0, 6: 1.0})
class Test_DistanceBand(ut.TestCase, Distance_Mixin):
def setUp(self):
Distance_Mixin.setUp(self)
self.grid_path = ps.examples.get_path('lattice10x10.shp')
self.grid_rook_w = c.Rook.from_shapefile(self.grid_path)
self.grid_f = ps.open(self.grid_path)
self.grid_points = get_points_array(self.grid_f)
self.grid_f.seek(0)
self.grid_kdt = KDTree(self.grid_points)
##########################
# Classmethod tests #
##########################
def test_init(self):
w = d.DistanceBand(self.grid_kdt, 1)
for k,v in w:
self.assertEquals(v, self.grid_rook_w[k])
def test_from_shapefile(self):
w = d.DistanceBand.from_shapefile(self.grid_path, 1)
for k,v in w:
self.assertEquals(v, self.grid_rook_w[k])
def test_from_array(self):
w = d.DistanceBand.from_array(self.grid_points, 1)
for k,v in w:
self.assertEquals(v, self.grid_rook_w[k])
@ut.skipIf(PANDAS_EXTINCT, 'Missing pandas')
def test_from_dataframe(self):
import pandas as pd
geom_series = ps.pdio.shp.shp2series(self.grid_path)
random_data = np.random.random(size=len(geom_series))
df = pd.DataFrame({'obs':random_data, 'geometry':geom_series})
w = d.DistanceBand.from_dataframe(df, 1)
for k,v in w:
self.assertEquals(v, self.grid_rook_w[k])
##########################
# Function/User tests #
##########################
def test_integers(self):
"""
see issue #126
"""
grid_integers = [tuple(map(int, poly.vertices[0]))
for poly in self.grid_f]
self.grid_f.seek(0)
grid_dbw = d.DistanceBand(grid_integers, 1)
for k,v in grid_dbw:
self.assertEquals(v, self.grid_rook_w[k])
def test_arcdist(self):
arc = ps.cg.sphere.arcdist
kdt = KDTree(self.arc_points, distance_metric='Arc',
radius=ps.cg.sphere.RADIUS_EARTH_KM)
npoints = self.arc_points.shape[0]
full = np.matrix([[arc(self.arc_points[i], self.arc_points[j])
for j in xrange(npoints)]
for i in xrange(npoints)])
maxdist = full.max()
w = d.DistanceBand(kdt, maxdist, binary=False, alpha=1.0)
np.testing.assert_allclose(w.sparse.todense(), full)
def test_dense(self):
w_rook = ps.weights.Rook.from_shapefile(
ps.examples.get_path('lattice10x10.shp'))
polys = ps.open(ps.examples.get_path('lattice10x10.shp'))
centroids = [p.centroid for p in polys]
w_db = d.DistanceBand(centroids, 1, build_sp=False)
for k in w_db.id_order:
np.testing.assert_equal(w_db[k], w_rook[k])
class Test_Kernel(ut.TestCase, Distance_Mixin):
def setUp(self):
Distance_Mixin.setUp(self)
self.known_wi0 = 0
self.known_w0 = {0: 1, 1: 0.500000049999995, 3: 0.4409830615267465}
self.known_wi1 = 0
self.known_w1 = {0: 1.0, 1: 0.33333333333333337,
3: 0.2546440075000701}
self.known_w1_bw = 15.
self.known_wi2 = 0
self.known_w2 = {0: 1.0, 1: 0.59999999999999998,
3: 0.55278640450004202, 4: 0.10557280900008403}
self.known_w2_bws = [25.0, 15.0, 25.0, 16.0, 14.5, 25.0]
self.known_wi3 = 0
self.known_w3 = [1.0, 0.10557289844279438, 9.9999990066379496e-08]
self.known_w3_abws =[[11.180341005532938], [11.180341005532938],
[20.000002000000002], [11.180341005532938],
[14.142137037944515], [18.027758180095585]]
self.known_wi4 = 0
self.known_w4 = {0: 0.3989422804014327,
1: 0.26741902915776961,
3: 0.24197074871621341}
self.known_w4_abws = self.known_w3_abws
self.known_wi5 = 1
self.known_w5 = {4: 0.0070787731484506233,
2: 0.2052478782400463,
3: 0.23051223027663237,
1: 1.0}
self.known_wi6 = 0
self.known_w6 = {0: 1.0, 2: 0.03178906767736345,
1: 9.9999990066379496e-08}
#stick answers & params here
##########################
# Classmethod tests #
##########################
def test_init(self):
w = d.Kernel(self.euclidean_kdt)
for k,v in w[self.known_wi0].items():
np.testing.assert_allclose(v, self.known_w0[k], rtol=RTOL)
def test_from_shapefile(self):
w = d.Kernel.from_shapefile(self.polygon_path, idVariable='POLYID')
for k,v in w[self.known_wi5].items():
np.testing.assert_allclose((k,v), (k,self.known_w5[k]), rtol=RTOL)
w = d.Kernel.from_shapefile(self.polygon_path, fixed=False)
for k,v in w[self.known_wi6].items():
np.testing.assert_allclose((k,v), (k,self.known_w6[k]), rtol=RTOL)
def test_from_array(self):
w = d.Kernel.from_array(self.points)
for k,v in w[self.known_wi0].items():
np.testing.assert_allclose(v, self.known_w0[k], rtol=RTOL)
@ut.skipIf(PANDAS_EXTINCT, 'Missing pandas')
def test_from_dataframe(self):
df = ps.pdio.read_files(self.polygon_path)
w = d.Kernel.from_dataframe(df)
for k,v in w[self.known_wi5-1].items():
np.testing.assert_allclose(v, self.known_w5[k+1], rtol=RTOL)
##########################
# Function/User tests #
##########################
def test_fixed_bandwidth(self):
w = d.Kernel(self.points, bandwidth=15.0)
for k,v in w[self.known_wi1].items():
np.testing.assert_allclose((k,v), (k, self.known_w1[k]))
np.testing.assert_allclose(np.ones((w.n,1))*15, w.bandwidth)
w = d.Kernel(self.points, bandwidth=self.known_w2_bws)
for k,v in w[self.known_wi2].items():
np.testing.assert_allclose((k,v), (k, self.known_w2[k]), rtol=RTOL)
for i in range(w.n):
np.testing.assert_allclose(w.bandwidth[i], self.known_w2_bws[i], rtol=RTOL)
def test_adaptive_bandwidth(self):
w = d.Kernel(self.points, fixed=False)
np.testing.assert_allclose(sorted(w[self.known_wi3].values()),
sorted(self.known_w3), rtol=RTOL)
bws = w.bandwidth.tolist()
np.testing.assert_allclose(bws, self.known_w3_abws, rtol=RTOL)
w = d.Kernel(self.points, fixed=False, function='gaussian')
for k,v in w[self.known_wi4].items():
np.testing.assert_allclose((k,v), (k, self.known_w4[k]), rtol=RTOL)
bws = w.bandwidth.tolist()
np.testing.assert_allclose(bws, self.known_w4_abws, rtol=RTOL)
knn = ut.TestLoader().loadTestsFromTestCase(Test_KNN)
kern = ut.TestLoader().loadTestsFromTestCase(Test_Kernel)
db = ut.TestLoader().loadTestsFromTestCase(Test_DistanceBand)
suite = ut.TestSuite([knn, kern, db])
if __name__ == '__main__':
runner = ut.TextTestRunner()
runner.run(suite)
| bsd-3-clause |
lancezlin/ml_template_py | lib/python2.7/site-packages/matplotlib/tests/test_table.py | 7 | 3776 | from __future__ import (absolute_import, division, print_function,
unicode_literals)
from matplotlib.externals import six
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.testing.decorators import image_comparison
from matplotlib.table import CustomCell
from matplotlib.path import Path
from nose.tools import assert_equal
@image_comparison(baseline_images=['table_zorder'],
extensions=['png'],
remove_text=True)
def test_zorder():
data = [[66386, 174296],
[58230, 381139]]
colLabels = ('Freeze', 'Wind')
rowLabels = ['%d year' % x for x in (100, 50)]
cellText = []
yoff = np.array([0.0] * len(colLabels))
for row in reversed(data):
yoff += row
cellText.append(['%1.1f' % (x/1000.0) for x in yoff])
t = np.linspace(0, 2*np.pi, 100)
plt.plot(t, np.cos(t), lw=4, zorder=2)
plt.table(cellText=cellText,
rowLabels=rowLabels,
colLabels=colLabels,
loc='center',
zorder=-2,
)
plt.table(cellText=cellText,
rowLabels=rowLabels,
colLabels=colLabels,
loc='upper center',
zorder=4,
)
plt.yticks([])
@image_comparison(baseline_images=['table_labels'],
extensions=['png'])
def test_label_colours():
dim = 3
c = np.linspace(0, 1, dim)
colours = plt.cm.RdYlGn(c)
cellText = [['1'] * dim] * dim
fig = plt.figure()
ax1 = fig.add_subplot(4, 1, 1)
ax1.axis('off')
ax1.table(cellText=cellText,
rowColours=colours,
loc='best')
ax2 = fig.add_subplot(4, 1, 2)
ax2.axis('off')
ax2.table(cellText=cellText,
rowColours=colours,
rowLabels=['Header'] * dim,
loc='best')
ax3 = fig.add_subplot(4, 1, 3)
ax3.axis('off')
ax3.table(cellText=cellText,
colColours=colours,
loc='best')
ax4 = fig.add_subplot(4, 1, 4)
ax4.axis('off')
ax4.table(cellText=cellText,
colColours=colours,
colLabels=['Header'] * dim,
loc='best')
@image_comparison(baseline_images=['table_cell_manipulation'],
extensions=['png'], remove_text=True)
def test_diff_cell_table():
cells = ('horizontal', 'vertical', 'open', 'closed', 'T', 'R', 'B', 'L')
cellText = [['1'] * len(cells)] * 2
colWidths = [0.1] * len(cells)
_, axes = plt.subplots(nrows=len(cells), figsize=(4, len(cells)+1))
for ax, cell in zip(axes, cells):
ax.table(
colWidths=colWidths,
cellText=cellText,
loc='center',
edges=cell,
)
ax.axis('off')
plt.tight_layout()
def test_customcell():
types = ('horizontal', 'vertical', 'open', 'closed', 'T', 'R', 'B', 'L')
codes = (
(Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO, Path.MOVETO),
(Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.LINETO),
(Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO),
(Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY),
(Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO),
(Path.MOVETO, Path.MOVETO, Path.LINETO, Path.MOVETO, Path.MOVETO),
(Path.MOVETO, Path.LINETO, Path.MOVETO, Path.MOVETO, Path.MOVETO),
(Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.MOVETO, Path.LINETO),
)
for t, c in zip(types, codes):
cell = CustomCell((0, 0), visible_edges=t, width=1, height=1)
code = tuple(s for _, s in cell.get_path().iter_segments())
assert_equal(c, code)
| mit |
rigetticomputing/pyquil | pyquil/wavefunction.py | 1 | 9032 | ##############################################################################
# Copyright 2018 Rigetti Computing
#
# 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.
##############################################################################
"""
Module containing the Wavefunction object and methods for working with wavefunctions.
"""
import itertools
import warnings
from typing import Dict, Iterator, List, Optional, Sequence, cast
import numpy as np
OCTETS_PER_DOUBLE_FLOAT = 8
OCTETS_PER_COMPLEX_DOUBLE = 2 * OCTETS_PER_DOUBLE_FLOAT
class Wavefunction(object):
"""
Encapsulate a wavefunction representing a quantum state
as returned by :py:class:`~pyquil.api.WavefunctionSimulator`.
.. note::
The elements of the wavefunction are ordered by bitstring. E.g., for two qubits the order
is ``00, 01, 10, 11``, where the the bits **are ordered in reverse** by the qubit index,
i.e., for qubits 0 and 1 the bitstring ``01`` indicates that qubit 0 is in the state 1.
See also :ref:`the related documentation section in the WavefunctionSimulator Overview
<basis_ordering>`.
"""
def __init__(self, amplitude_vector: np.ndarray):
"""
Initializes a wavefunction
:param amplitude_vector: A numpy array of complex amplitudes
"""
if len(amplitude_vector) == 0 or len(amplitude_vector) & (len(amplitude_vector) - 1) != 0:
raise TypeError("Amplitude vector must have a length that is a power of two")
self.amplitudes = np.asarray(amplitude_vector)
sumprob = np.sum(self.probabilities())
if not np.isclose(sumprob, 1.0):
raise ValueError(
"The wavefunction is not normalized. "
"The probabilities sum to {} instead of 1".format(sumprob)
)
@staticmethod
def ground(qubit_num: int) -> "Wavefunction":
warnings.warn("ground() has been deprecated in favor of zeros()", stacklevel=2)
return Wavefunction.zeros(qubit_num)
@staticmethod
def zeros(qubit_num: int) -> "Wavefunction":
"""
Constructs the groundstate wavefunction for a given number of qubits.
:param qubit_num:
:return: A Wavefunction in the ground state
"""
amplitude_vector = np.zeros(2 ** qubit_num)
amplitude_vector[0] = 1.0
return Wavefunction(amplitude_vector)
@staticmethod
def from_bit_packed_string(coef_string: bytes) -> "Wavefunction":
"""
From a bit packed string, unpacks to get the wavefunction
:param coef_string:
"""
num_cfloat = len(coef_string) // OCTETS_PER_COMPLEX_DOUBLE
amplitude_vector = np.ndarray(shape=(num_cfloat,), buffer=coef_string, dtype=">c16")
return Wavefunction(amplitude_vector)
def __len__(self) -> int:
return len(self.amplitudes).bit_length() - 1
def __iter__(self) -> Iterator[complex]:
return cast(Iterator[complex], self.amplitudes.__iter__())
def __getitem__(self, index: int) -> complex:
return cast(complex, self.amplitudes[index])
def __setitem__(self, key: int, value: complex) -> None:
self.amplitudes[key] = value
def __str__(self) -> str:
return self.pretty_print(decimal_digits=10)
def probabilities(self) -> np.ndarray:
"""Returns an array of probabilities in lexicographical order"""
return np.abs(self.amplitudes) ** 2
def get_outcome_probs(self) -> Dict[str, float]:
"""
Parses a wavefunction (array of complex amplitudes) and returns a dictionary of
outcomes and associated probabilities.
:return: A dict with outcomes as keys and probabilities as values.
:rtype: dict
"""
outcome_dict = {}
qubit_num = len(self)
for index, amplitude in enumerate(self.amplitudes):
outcome = get_bitstring_from_index(index, qubit_num)
outcome_dict[outcome] = abs(amplitude) ** 2
return outcome_dict
def pretty_print_probabilities(self, decimal_digits: int = 2) -> Dict[str, float]:
"""
TODO: This doesn't seem like it is named correctly...
Prints outcome probabilities, ignoring all outcomes with approximately zero probabilities
(up to a certain number of decimal digits) and rounding the probabilities to decimal_digits.
:param int decimal_digits: The number of digits to truncate to.
:return: A dict with outcomes as keys and probabilities as values.
"""
outcome_dict = {}
qubit_num = len(self)
for index, amplitude in enumerate(self.amplitudes):
outcome = get_bitstring_from_index(index, qubit_num)
prob = round(abs(amplitude) ** 2, decimal_digits)
if prob != 0.0:
outcome_dict[outcome] = prob
return outcome_dict
def pretty_print(self, decimal_digits: int = 2) -> str:
"""
Returns a string repr of the wavefunction, ignoring all outcomes with approximately zero
amplitude (up to a certain number of decimal digits) and rounding the amplitudes to
decimal_digits.
:param int decimal_digits: The number of digits to truncate to.
:return: A string representation of the wavefunction.
"""
outcome_dict = {}
qubit_num = len(self)
pp_string = ""
for index, amplitude in enumerate(self.amplitudes):
outcome = get_bitstring_from_index(index, qubit_num)
amplitude = (
round(amplitude.real, decimal_digits) + round(amplitude.imag, decimal_digits) * 1.0j
)
if amplitude != 0.0:
outcome_dict[outcome] = amplitude
pp_string += str(amplitude) + "|{}> + ".format(outcome)
if len(pp_string) >= 3:
pp_string = pp_string[:-3] # remove the dangling + if it is there
return pp_string
def plot(self, qubit_subset: Optional[Sequence[int]] = None) -> None:
"""
TODO: calling this will error because of matplotlib
Plots a bar chart with bitstring on the x axis and probability on the y axis.
:param qubit_subset: Optional parameter used for plotting a subset of the Hilbert space.
"""
import matplotlib.pyplot as plt
prob_dict = self.get_outcome_probs()
if qubit_subset:
sub_dict = {}
qubit_num = len(self)
for i in qubit_subset:
if i > (2 ** qubit_num - 1):
raise IndexError("Index {} too large for {} qubits.".format(i, qubit_num))
else:
sub_dict[get_bitstring_from_index(i, qubit_num)] = prob_dict[
get_bitstring_from_index(i, qubit_num)
]
prob_dict = sub_dict
plt.bar(range(len(prob_dict)), prob_dict.values(), align="center", color="#6CAFB7")
plt.xticks(range(len(prob_dict)), prob_dict.keys())
plt.show()
def sample_bitstrings(self, n_samples: int) -> np.ndarray:
"""
Sample bitstrings from the distribution defined by the wavefunction.
:param n_samples: The number of bitstrings to sample
:return: An array of shape (n_samples, n_qubits)
"""
possible_bitstrings = np.array(list(itertools.product((0, 1), repeat=len(self))))
inds = np.random.choice(2 ** len(self), n_samples, p=self.probabilities())
bitstrings = possible_bitstrings[inds, :]
return bitstrings
def get_bitstring_from_index(index: int, qubit_num: int) -> str:
"""
Returns the bitstring in lexical order that corresponds to the given index in 0 to 2^(qubit_num)
:param int index:
:param int qubit_num:
:return: the bitstring
:rtype: str
"""
if index > (2 ** qubit_num - 1):
raise IndexError("Index {} too large for {} qubits.".format(index, qubit_num))
return bin(index)[2:].rjust(qubit_num, "0")
def _octet_bits(o: int) -> List[int]:
"""
Get the bits of an octet.
:param o: The octets.
:return: The bits as a list in LSB-to-MSB order.
"""
if not isinstance(o, int):
raise TypeError("o should be an int")
if not (0 <= o <= 255):
raise ValueError("o should be between 0 and 255 inclusive")
bits = [0] * 8
for i in range(8):
if 1 == o & 1:
bits[i] = 1
o = o >> 1
return bits
| apache-2.0 |
elkingtonmcb/nupic | external/linux32/lib/python2.6/site-packages/matplotlib/backends/backend_agg.py | 69 | 11729 | """
An agg http://antigrain.com/ backend
Features that are implemented
* capstyles and join styles
* dashes
* linewidth
* lines, rectangles, ellipses
* clipping to a rectangle
* output to RGBA and PNG
* alpha blending
* DPI scaling properly - everything scales properly (dashes, linewidths, etc)
* draw polygon
* freetype2 w/ ft2font
TODO:
* allow save to file handle
* integrate screen dpi w/ ppi and text
"""
from __future__ import division
import numpy as npy
from matplotlib import verbose, rcParams
from matplotlib.backend_bases import RendererBase,\
FigureManagerBase, FigureCanvasBase
from matplotlib.cbook import is_string_like, maxdict
from matplotlib.figure import Figure
from matplotlib.font_manager import findfont
from matplotlib.ft2font import FT2Font, LOAD_FORCE_AUTOHINT
from matplotlib.mathtext import MathTextParser
from matplotlib.path import Path
from matplotlib.transforms import Bbox
from _backend_agg import RendererAgg as _RendererAgg
from matplotlib import _png
backend_version = 'v2.2'
class RendererAgg(RendererBase):
"""
The renderer handles all the drawing primitives using a graphics
context instance that controls the colors/styles
"""
debug=1
texd = maxdict(50) # a cache of tex image rasters
_fontd = maxdict(50)
def __init__(self, width, height, dpi):
if __debug__: verbose.report('RendererAgg.__init__', 'debug-annoying')
RendererBase.__init__(self)
self.dpi = dpi
self.width = width
self.height = height
if __debug__: verbose.report('RendererAgg.__init__ width=%s, height=%s'%(width, height), 'debug-annoying')
self._renderer = _RendererAgg(int(width), int(height), dpi, debug=False)
if __debug__: verbose.report('RendererAgg.__init__ _RendererAgg done',
'debug-annoying')
#self.draw_path = self._renderer.draw_path # see below
self.draw_markers = self._renderer.draw_markers
self.draw_path_collection = self._renderer.draw_path_collection
self.draw_quad_mesh = self._renderer.draw_quad_mesh
self.draw_image = self._renderer.draw_image
self.copy_from_bbox = self._renderer.copy_from_bbox
self.restore_region = self._renderer.restore_region
self.tostring_rgba_minimized = self._renderer.tostring_rgba_minimized
self.mathtext_parser = MathTextParser('Agg')
self.bbox = Bbox.from_bounds(0, 0, self.width, self.height)
if __debug__: verbose.report('RendererAgg.__init__ done',
'debug-annoying')
def draw_path(self, gc, path, transform, rgbFace=None):
nmax = rcParams['agg.path.chunksize'] # here at least for testing
npts = path.vertices.shape[0]
if nmax > 100 and npts > nmax and path.should_simplify and rgbFace is None:
nch = npy.ceil(npts/float(nmax))
chsize = int(npy.ceil(npts/nch))
i0 = npy.arange(0, npts, chsize)
i1 = npy.zeros_like(i0)
i1[:-1] = i0[1:] - 1
i1[-1] = npts
for ii0, ii1 in zip(i0, i1):
v = path.vertices[ii0:ii1,:]
c = path.codes
if c is not None:
c = c[ii0:ii1]
c[0] = Path.MOVETO # move to end of last chunk
p = Path(v, c)
self._renderer.draw_path(gc, p, transform, rgbFace)
else:
self._renderer.draw_path(gc, path, transform, rgbFace)
def draw_mathtext(self, gc, x, y, s, prop, angle):
"""
Draw the math text using matplotlib.mathtext
"""
if __debug__: verbose.report('RendererAgg.draw_mathtext',
'debug-annoying')
ox, oy, width, height, descent, font_image, used_characters = \
self.mathtext_parser.parse(s, self.dpi, prop)
x = int(x) + ox
y = int(y) - oy
self._renderer.draw_text_image(font_image, x, y + 1, angle, gc)
def draw_text(self, gc, x, y, s, prop, angle, ismath):
"""
Render the text
"""
if __debug__: verbose.report('RendererAgg.draw_text', 'debug-annoying')
if ismath:
return self.draw_mathtext(gc, x, y, s, prop, angle)
font = self._get_agg_font(prop)
if font is None: return None
if len(s) == 1 and ord(s) > 127:
font.load_char(ord(s), flags=LOAD_FORCE_AUTOHINT)
else:
# We pass '0' for angle here, since it will be rotated (in raster
# space) in the following call to draw_text_image).
font.set_text(s, 0, flags=LOAD_FORCE_AUTOHINT)
font.draw_glyphs_to_bitmap()
#print x, y, int(x), int(y)
self._renderer.draw_text_image(font.get_image(), int(x), int(y) + 1, angle, gc)
def get_text_width_height_descent(self, s, prop, ismath):
"""
get the width and height in display coords of the string s
with FontPropertry prop
# passing rgb is a little hack to make cacheing in the
# texmanager more efficient. It is not meant to be used
# outside the backend
"""
if ismath=='TeX':
# todo: handle props
size = prop.get_size_in_points()
texmanager = self.get_texmanager()
Z = texmanager.get_grey(s, size, self.dpi)
m,n = Z.shape
# TODO: descent of TeX text (I am imitating backend_ps here -JKS)
return n, m, 0
if ismath:
ox, oy, width, height, descent, fonts, used_characters = \
self.mathtext_parser.parse(s, self.dpi, prop)
return width, height, descent
font = self._get_agg_font(prop)
font.set_text(s, 0.0, flags=LOAD_FORCE_AUTOHINT) # the width and height of unrotated string
w, h = font.get_width_height()
d = font.get_descent()
w /= 64.0 # convert from subpixels
h /= 64.0
d /= 64.0
return w, h, d
def draw_tex(self, gc, x, y, s, prop, angle):
# todo, handle props, angle, origins
size = prop.get_size_in_points()
texmanager = self.get_texmanager()
key = s, size, self.dpi, angle, texmanager.get_font_config()
im = self.texd.get(key)
if im is None:
Z = texmanager.get_grey(s, size, self.dpi)
Z = npy.array(Z * 255.0, npy.uint8)
self._renderer.draw_text_image(Z, x, y, angle, gc)
def get_canvas_width_height(self):
'return the canvas width and height in display coords'
return self.width, self.height
def _get_agg_font(self, prop):
"""
Get the font for text instance t, cacheing for efficiency
"""
if __debug__: verbose.report('RendererAgg._get_agg_font',
'debug-annoying')
key = hash(prop)
font = self._fontd.get(key)
if font is None:
fname = findfont(prop)
font = self._fontd.get(fname)
if font is None:
font = FT2Font(str(fname))
self._fontd[fname] = font
self._fontd[key] = font
font.clear()
size = prop.get_size_in_points()
font.set_size(size, self.dpi)
return font
def points_to_pixels(self, points):
"""
convert point measures to pixes using dpi and the pixels per
inch of the display
"""
if __debug__: verbose.report('RendererAgg.points_to_pixels',
'debug-annoying')
return points*self.dpi/72.0
def tostring_rgb(self):
if __debug__: verbose.report('RendererAgg.tostring_rgb',
'debug-annoying')
return self._renderer.tostring_rgb()
def tostring_argb(self):
if __debug__: verbose.report('RendererAgg.tostring_argb',
'debug-annoying')
return self._renderer.tostring_argb()
def buffer_rgba(self,x,y):
if __debug__: verbose.report('RendererAgg.buffer_rgba',
'debug-annoying')
return self._renderer.buffer_rgba(x,y)
def clear(self):
self._renderer.clear()
def option_image_nocomposite(self):
# It is generally faster to composite each image directly to
# the Figure, and there's no file size benefit to compositing
# with the Agg backend
return True
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
if __debug__: verbose.report('backend_agg.new_figure_manager',
'debug-annoying')
FigureClass = kwargs.pop('FigureClass', Figure)
thisFig = FigureClass(*args, **kwargs)
canvas = FigureCanvasAgg(thisFig)
manager = FigureManagerBase(canvas, num)
return manager
class FigureCanvasAgg(FigureCanvasBase):
"""
The canvas the figure renders into. Calls the draw and print fig
methods, creates the renderers, etc...
Public attribute
figure - A Figure instance
"""
def copy_from_bbox(self, bbox):
renderer = self.get_renderer()
return renderer.copy_from_bbox(bbox)
def restore_region(self, region):
renderer = self.get_renderer()
return renderer.restore_region(region)
def draw(self):
"""
Draw the figure using the renderer
"""
if __debug__: verbose.report('FigureCanvasAgg.draw', 'debug-annoying')
self.renderer = self.get_renderer()
self.figure.draw(self.renderer)
def get_renderer(self):
l, b, w, h = self.figure.bbox.bounds
key = w, h, self.figure.dpi
try: self._lastKey, self.renderer
except AttributeError: need_new_renderer = True
else: need_new_renderer = (self._lastKey != key)
if need_new_renderer:
self.renderer = RendererAgg(w, h, self.figure.dpi)
self._lastKey = key
return self.renderer
def tostring_rgb(self):
if __debug__: verbose.report('FigureCanvasAgg.tostring_rgb',
'debug-annoying')
return self.renderer.tostring_rgb()
def tostring_argb(self):
if __debug__: verbose.report('FigureCanvasAgg.tostring_argb',
'debug-annoying')
return self.renderer.tostring_argb()
def buffer_rgba(self,x,y):
if __debug__: verbose.report('FigureCanvasAgg.buffer_rgba',
'debug-annoying')
return self.renderer.buffer_rgba(x,y)
def get_default_filetype(self):
return 'png'
def print_raw(self, filename_or_obj, *args, **kwargs):
FigureCanvasAgg.draw(self)
renderer = self.get_renderer()
original_dpi = renderer.dpi
renderer.dpi = self.figure.dpi
if is_string_like(filename_or_obj):
filename_or_obj = file(filename_or_obj, 'wb')
renderer._renderer.write_rgba(filename_or_obj)
renderer.dpi = original_dpi
print_rgba = print_raw
def print_png(self, filename_or_obj, *args, **kwargs):
FigureCanvasAgg.draw(self)
renderer = self.get_renderer()
original_dpi = renderer.dpi
renderer.dpi = self.figure.dpi
if is_string_like(filename_or_obj):
filename_or_obj = file(filename_or_obj, 'wb')
_png.write_png(renderer._renderer.buffer_rgba(0, 0),
renderer.width, renderer.height,
filename_or_obj, self.figure.dpi)
renderer.dpi = original_dpi
| agpl-3.0 |
bennlich/scikit-image | doc/examples/plot_restoration.py | 17 | 1960 | # -*- coding: utf-8 -*-
"""
=====================
Image Deconvolution
=====================
In this example, we deconvolve a noisy version of an image using Wiener
and unsupervised Wiener algorithms. This algorithms are based on
linear models that can't restore sharp edge as much as non-linear
methods (like TV restoration) but are much faster.
Wiener filter
-------------
The inverse filter based on the PSF (Point Spread Function),
the prior regularisation (penalisation of high frequency) and the
tradeoff between the data and prior adequacy. The regularization
parameter must be hand tuned.
Unsupervised Wiener
-------------------
This algorithm has a self-tuned regularisation parameters based on
data learning. This is not common and based on the following
publication. The algorithm is based on a iterative Gibbs sampler that
draw alternatively samples of posterior conditionnal law of the image,
the noise power and the image frequency power.
.. [1] François Orieux, Jean-François Giovannelli, and Thomas
Rodet, "Bayesian estimation of regularization and point
spread function parameters for Wiener-Hunt deconvolution",
J. Opt. Soc. Am. A 27, 1593-1607 (2010)
"""
import numpy as np
import matplotlib.pyplot as plt
from skimage import color, data, restoration
astro = color.rgb2gray(data.astronaut())
from scipy.signal import convolve2d as conv2
psf = np.ones((5, 5)) / 25
astro = conv2(astro, psf, 'same')
astro += 0.1 * astro.std() * np.random.standard_normal(astro.shape)
deconvolved, _ = restoration.unsupervised_wiener(astro, psf)
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(8, 5))
plt.gray()
ax[0].imshow(astro, vmin=deconvolved.min(), vmax=deconvolved.max())
ax[0].axis('off')
ax[0].set_title('Data')
ax[1].imshow(deconvolved)
ax[1].axis('off')
ax[1].set_title('Self tuned restoration')
fig.subplots_adjust(wspace=0.02, hspace=0.2,
top=0.9, bottom=0.05, left=0, right=1)
plt.show()
| bsd-3-clause |
vibhorag/scikit-learn | sklearn/neural_network/tests/test_rbm.py | 225 | 6278 | import sys
import re
import numpy as np
from scipy.sparse import csc_matrix, csr_matrix, lil_matrix
from sklearn.utils.testing import (assert_almost_equal, assert_array_equal,
assert_true)
from sklearn.datasets import load_digits
from sklearn.externals.six.moves import cStringIO as StringIO
from sklearn.neural_network import BernoulliRBM
from sklearn.utils.validation import assert_all_finite
np.seterr(all='warn')
Xdigits = load_digits().data
Xdigits -= Xdigits.min()
Xdigits /= Xdigits.max()
def test_fit():
X = Xdigits.copy()
rbm = BernoulliRBM(n_components=64, learning_rate=0.1,
batch_size=10, n_iter=7, random_state=9)
rbm.fit(X)
assert_almost_equal(rbm.score_samples(X).mean(), -21., decimal=0)
# in-place tricks shouldn't have modified X
assert_array_equal(X, Xdigits)
def test_partial_fit():
X = Xdigits.copy()
rbm = BernoulliRBM(n_components=64, learning_rate=0.1,
batch_size=20, random_state=9)
n_samples = X.shape[0]
n_batches = int(np.ceil(float(n_samples) / rbm.batch_size))
batch_slices = np.array_split(X, n_batches)
for i in range(7):
for batch in batch_slices:
rbm.partial_fit(batch)
assert_almost_equal(rbm.score_samples(X).mean(), -21., decimal=0)
assert_array_equal(X, Xdigits)
def test_transform():
X = Xdigits[:100]
rbm1 = BernoulliRBM(n_components=16, batch_size=5,
n_iter=5, random_state=42)
rbm1.fit(X)
Xt1 = rbm1.transform(X)
Xt2 = rbm1._mean_hiddens(X)
assert_array_equal(Xt1, Xt2)
def test_small_sparse():
# BernoulliRBM should work on small sparse matrices.
X = csr_matrix(Xdigits[:4])
BernoulliRBM().fit(X) # no exception
def test_small_sparse_partial_fit():
for sparse in [csc_matrix, csr_matrix]:
X_sparse = sparse(Xdigits[:100])
X = Xdigits[:100].copy()
rbm1 = BernoulliRBM(n_components=64, learning_rate=0.1,
batch_size=10, random_state=9)
rbm2 = BernoulliRBM(n_components=64, learning_rate=0.1,
batch_size=10, random_state=9)
rbm1.partial_fit(X_sparse)
rbm2.partial_fit(X)
assert_almost_equal(rbm1.score_samples(X).mean(),
rbm2.score_samples(X).mean(),
decimal=0)
def test_sample_hiddens():
rng = np.random.RandomState(0)
X = Xdigits[:100]
rbm1 = BernoulliRBM(n_components=2, batch_size=5,
n_iter=5, random_state=42)
rbm1.fit(X)
h = rbm1._mean_hiddens(X[0])
hs = np.mean([rbm1._sample_hiddens(X[0], rng) for i in range(100)], 0)
assert_almost_equal(h, hs, decimal=1)
def test_fit_gibbs():
# Gibbs on the RBM hidden layer should be able to recreate [[0], [1]]
# from the same input
rng = np.random.RandomState(42)
X = np.array([[0.], [1.]])
rbm1 = BernoulliRBM(n_components=2, batch_size=2,
n_iter=42, random_state=rng)
# you need that much iters
rbm1.fit(X)
assert_almost_equal(rbm1.components_,
np.array([[0.02649814], [0.02009084]]), decimal=4)
assert_almost_equal(rbm1.gibbs(X), X)
return rbm1
def test_fit_gibbs_sparse():
# Gibbs on the RBM hidden layer should be able to recreate [[0], [1]] from
# the same input even when the input is sparse, and test against non-sparse
rbm1 = test_fit_gibbs()
rng = np.random.RandomState(42)
from scipy.sparse import csc_matrix
X = csc_matrix([[0.], [1.]])
rbm2 = BernoulliRBM(n_components=2, batch_size=2,
n_iter=42, random_state=rng)
rbm2.fit(X)
assert_almost_equal(rbm2.components_,
np.array([[0.02649814], [0.02009084]]), decimal=4)
assert_almost_equal(rbm2.gibbs(X), X.toarray())
assert_almost_equal(rbm1.components_, rbm2.components_)
def test_gibbs_smoke():
# Check if we don't get NaNs sampling the full digits dataset.
# Also check that sampling again will yield different results.
X = Xdigits
rbm1 = BernoulliRBM(n_components=42, batch_size=40,
n_iter=20, random_state=42)
rbm1.fit(X)
X_sampled = rbm1.gibbs(X)
assert_all_finite(X_sampled)
X_sampled2 = rbm1.gibbs(X)
assert_true(np.all((X_sampled != X_sampled2).max(axis=1)))
def test_score_samples():
# Test score_samples (pseudo-likelihood) method.
# Assert that pseudo-likelihood is computed without clipping.
# See Fabian's blog, http://bit.ly/1iYefRk
rng = np.random.RandomState(42)
X = np.vstack([np.zeros(1000), np.ones(1000)])
rbm1 = BernoulliRBM(n_components=10, batch_size=2,
n_iter=10, random_state=rng)
rbm1.fit(X)
assert_true((rbm1.score_samples(X) < -300).all())
# Sparse vs. dense should not affect the output. Also test sparse input
# validation.
rbm1.random_state = 42
d_score = rbm1.score_samples(X)
rbm1.random_state = 42
s_score = rbm1.score_samples(lil_matrix(X))
assert_almost_equal(d_score, s_score)
# Test numerical stability (#2785): would previously generate infinities
# and crash with an exception.
with np.errstate(under='ignore'):
rbm1.score_samples([np.arange(1000) * 100])
def test_rbm_verbose():
rbm = BernoulliRBM(n_iter=2, verbose=10)
old_stdout = sys.stdout
sys.stdout = StringIO()
try:
rbm.fit(Xdigits)
finally:
sys.stdout = old_stdout
def test_sparse_and_verbose():
# Make sure RBM works with sparse input when verbose=True
old_stdout = sys.stdout
sys.stdout = StringIO()
from scipy.sparse import csc_matrix
X = csc_matrix([[0.], [1.]])
rbm = BernoulliRBM(n_components=2, batch_size=2, n_iter=1,
random_state=42, verbose=True)
try:
rbm.fit(X)
s = sys.stdout.getvalue()
# make sure output is sound
assert_true(re.match(r"\[BernoulliRBM\] Iteration 1,"
r" pseudo-likelihood = -?(\d)+(\.\d+)?,"
r" time = (\d|\.)+s",
s))
finally:
sys.stdout = old_stdout
| bsd-3-clause |
micahhausler/pandashells | pandashells/test/p_plot_test.py | 7 | 1077 | #! /usr/bin/env python
from mock import patch, MagicMock
from unittest import TestCase
from pandashells.bin.p_plot import main
class MainTests(TestCase):
@patch('pandashells.bin.p_plot.argparse.ArgumentParser')
@patch('pandashells.bin.p_plot.arg_lib.add_args')
@patch('pandashells.bin.p_plot.io_lib.df_from_input')
@patch('pandashells.bin.p_plot.plot_lib.set_plot_styling')
@patch('pandashells.bin.p_plot.plot_lib.draw_xy_plot')
def test_plotting(
self, draw_xy_mock, set_plot_styling_mock, df_from_input_mock,
add_args_mock, ArgumentParserMock):
args = MagicMock()
parser = MagicMock(parse_args=MagicMock(return_value=args))
ArgumentParserMock.return_value = parser
df_from_input_mock.return_value = 'df'
main()
add_args_mock.assert_called_with(
parser, 'io_in', 'xy_plotting', 'decorating', 'example')
df_from_input_mock.assert_called_with(args)
set_plot_styling_mock.assert_called_with(args)
draw_xy_mock.assert_called_with(args, 'df')
| bsd-2-clause |
peterhogan/python | maze_wiki.py | 1 | 2851 | # Code by Erik Sweet and Bill Basener
import random
import numpy as np
from matplotlib import pyplot as plt
import matplotlib.cm as cm
num_rows = int(input("Rows: ")) # number of rows
num_cols = int(input("Columns: ")) # number of columns
M = np.zeros((num_rows,num_cols,5), dtype=np.uint8)
# The array M is going to hold the array information for each cell.
# The first four coordinates tell if walls exist on those sides
# and the fifth indicates if the cell has been visited in the search.
# M(LEFT, UP, RIGHT, DOWN, CHECK_IF_VISITED)
image = np.zeros((num_rows*10,num_cols*10), dtype=np.uint8)
# The array image is going to be the output image to display
# Set starting row and column
r = 0
c = 0
history = [(r,c)] # The history is the
# Trace a path though the cells of the maze and open walls along the path.
# We do this with a while loop, repeating the loop until there is no history,
# which would mean we backtracked to the initial start.
while history:
M[r,c,4] = 1 # designate this location as visited
# check if the adjacent cells are valid for moving to
check = []
if c > 0 and M[r,c-1,4] == 0:
check.append('L')
if r > 0 and M[r-1,c,4] == 0:
check.append('U')
if c < num_cols-1 and M[r,c+1,4] == 0:
check.append('R')
if r < num_rows-1 and M[r+1,c,4] == 0:
check.append('D')
if len(check): # If there is a valid cell to move to.
# Mark the walls between cells as open if we move
history.append([r,c])
move_direction = random.choice(check)
if move_direction == 'L':
M[r,c,0] = 1
c = c-1
M[r,c,2] = 1
if move_direction == 'U':
M[r,c,1] = 1
r = r-1
M[r,c,3] = 1
if move_direction == 'R':
M[r,c,2] = 1
c = c+1
M[r,c,0] = 1
if move_direction == 'D':
M[r,c,3] = 1
r = r+1
M[r,c,1] = 1
else: # If there are no valid cells to move to.
# retrace one step back in history if no move is possible
r,c = history.pop()
# Open the walls at the start and finish
M[0,0,0] = 1
M[num_rows-1,num_cols-1,2] = 1
# Generate the image for display
for row in range(0,num_rows):
for col in range(0,num_cols):
cell_data = M[row,col]
for i in range(10*row+1,10*row+9):
image[i,range(10*col+1,10*col+9)] = 255
if cell_data[0] == 1:image[range(10*row+1,10*row+9),10*col] = 255
if cell_data[1] == 1:image[10*row,range(10*col+1,10*col+9)] = 255
if cell_data[2] == 1:image[range(10*row+1,10*row+9),10*col+9] = 255
if cell_data[3] == 1:image[10*row+9,range(10*col+1,10*col+9)] = 255
# Display the image
plt.imshow(image, cmap = cm.Greys_r, interpolation='none')
plt.show()
| mit |
nipy/nireg | scripts/scripting.py | 3 | 6418 | #!/usr/bin/env python
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""
A scripting wrapper around 4D registration (SpaceTimeRealign)
"""
from __future__ import absolute_import
import os
import os.path as op
import numpy as np
import numpy.linalg as npl
import nibabel as nib
from nibabel.filename_parser import splitext_addext
import nibabel.eulerangles as euler
from nibabel.optpkg import optional_package
matplotlib, HAVE_MPL, _ = optional_package('matplotlib')
if HAVE_MPL:
import matplotlib.pyplot as plt
from .groupwise_registration import SpaceTimeRealign
import nipy.algorithms.slicetiming as st
from nipy.io.api import save_image
timefuncs = st.timefuncs.SLICETIME_FUNCTIONS
__all__ = ["space_time_realign", "aff2euler"]
def aff2euler(affine):
"""
Compute Euler angles from 4 x 4 `affine`
Parameters
----------
affine : 4 by 4 array
An affine transformation matrix
Returns
-------
The Euler angles associated with the affine
"""
return euler.mat2euler(aff2rot_zooms(affine)[0])
def aff2rot_zooms(affine):
"""
Compute a rotation matrix and zooms from 4 x 4 `affine`
Parameters
----------
affine : 4 by 4 array
An affine transformation matrix
Returns
-------
R: 3 by 3 array
A rotation matrix in 3D
zooms: length 3 1-d array
Vector with voxel sizes.
"""
RZS = affine[:3, :3]
zooms = np.sqrt(np.sum(RZS * RZS, axis=0))
RS = RZS / zooms
# Adjust zooms to make RS correspond (below) to a true
# rotation matrix.
if npl.det(RS) < 0:
zooms[0] *= -1
RS[:,0] *= -1
# retrieve rotation matrix from RS with polar decomposition.
# Discard shears
P, S, Qs = npl.svd(RS)
R = np.dot(P, Qs)
return R, zooms
def space_time_realign(input, tr, slice_order='descending', slice_dim=2,
slice_dir=1, apply=True, make_figure=False,
out_name=None):
"""
This is a scripting interface to `nipy.algorithms.registration.SpaceTimeRealign`
Parameters
----------
input : str or list
A full path to a file-name (4D nifti time-series) , or to a directory
containing 4D nifti time-series, or a list of full-paths to files.
tr : float
The repetition time
slice_order : str (optional)
This is the order of slice-times in the acquisition. This is used as a
key into the ``SLICETIME_FUNCTIONS`` dictionary from
:mod:`nipy.algorithms.slicetiming.timefuncs`. Default: 'descending'.
slice_dim : int (optional)
Denotes the axis in `images` that is the slice axis. In a 4D image,
this will often be axis = 2 (default).
slice_dir : int (optional)
1 if the slices were acquired slice 0 first (default), slice -1 last,
or -1 if acquire slice -1 first, slice 0 last.
apply : bool (optional)
Whether to apply the transformation and produce an output. Default:
True.
make_figure : bool (optional)
Whether to generate a .png figure with the parameters across scans.
out_name : bool (optional)
Specify an output location (full path) for the files that are
generated. Default: generate files in the path of the inputs (with an
`_mc` suffix added to the file-names.
Returns
-------
transforms : ndarray
An (n_times_points,) shaped array containing
`nipy.algorithms.registration.affine.Rigid` class instances for each time
point in the time-series. These can be used as affine transforms by
referring to their `.as_affine` attribute.
"""
if make_figure:
if not HAVE_MPL:
e_s ="You need to have matplotlib installed to run this function"
e_s += " with `make_figure` set to `True`"
raise RuntimeError(e_s)
# If we got only a single file, we motion correct that one:
if op.isfile(input):
if not (input.endswith('.nii') or input.endswith('.nii.gz')):
e_s = "Input needs to be a nifti file ('.nii' or '.nii.gz'"
raise ValueError(e_s)
fnames = [input]
input = nib.load(input)
# If this is a full-path to a directory containing files, it's still a
# string:
elif isinstance(input, str):
list_of_files = os.listdir(input)
fnames = [op.join(input, f) for f in np.sort(list_of_files)
if (f.endswith('.nii') or f.endswith('.nii.gz')) ]
input = [nib.load(x) for x in fnames]
# Assume that it's a list of full-paths to files:
else:
input = [nib.load(x) for x in input]
slice_times = timefuncs[slice_order]
slice_info = [slice_dim,
slice_dir]
reggy = SpaceTimeRealign(input,
tr,
slice_times,
slice_info)
reggy.estimate(align_runs=True)
# We now have the transformation parameters in here:
transforms = np.squeeze(np.array(reggy._transforms))
rot = np.array([t.rotation for t in transforms])
trans = np.array([t.translation for t in transforms])
if apply:
new_reggy = reggy.resample(align_runs=True)
for run_idx, new_im in enumerate(new_reggy):
# Fix output TR - it was probably lost in the image realign step
assert new_im.affine.shape == (5, 5)
new_im.affine[:] = new_im.affine.dot(np.diag([1, 1, 1, tr, 1]))
# Save it out to a '.nii.gz' file:
froot, ext, trail_ext = splitext_addext(fnames[run_idx])
path, fname = op.split(froot)
# We retain the file-name adding '_mc' regardless of where it's
# saved
new_path = path if out_name is None else out_name
save_image(new_im, op.join(new_path, fname + '_mc.nii.gz'))
if make_figure:
figure, ax = plt.subplots(2)
figure.set_size_inches([8, 6])
ax[0].plot(rot)
ax[0].set_xlabel('Time (TR)')
ax[0].set_ylabel('Translation (mm)')
ax[1].plot(trans)
ax[1].set_xlabel('Time (TR)')
ax[1].set_ylabel('Rotation (radians)')
figure.savefig(op.join(os.path.split(fnames[0])[0],
'mc_params.png'))
return transforms
| bsd-3-clause |
juharris/tensorflow | tensorflow/examples/skflow/mnist.py | 8 | 3167 | # 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 showcases how simple it is to build image classification networks.
It follows description from this TensorFlow tutorial:
https://www.tensorflow.org/versions/master/tutorials/mnist/pros/index.html#deep-mnist-for-experts
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from sklearn import metrics
import tensorflow as tf
from tensorflow.contrib import learn
### Download and load MNIST data.
mnist = learn.datasets.load_dataset('mnist')
### Linear classifier.
feature_columns = learn.infer_real_valued_columns_from_input(mnist.train.images)
classifier = learn.LinearClassifier(
feature_columns=feature_columns, n_classes=10)
classifier.fit(mnist.train.images, mnist.train.labels, batch_size=100,
steps=1000)
score = metrics.accuracy_score(
mnist.test.labels, classifier.predict(mnist.test.images))
print('Accuracy: {0:f}'.format(score))
### Convolutional network
def max_pool_2x2(tensor_in):
return tf.nn.max_pool(
tensor_in, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
def conv_model(X, y):
# pylint: disable=invalid-name,missing-docstring
# reshape X to 4d tensor with 2nd and 3rd dimensions being image width and
# height final dimension being the number of color channels.
X = tf.reshape(X, [-1, 28, 28, 1])
# first conv layer will compute 32 features for each 5x5 patch
with tf.variable_scope('conv_layer1'):
h_conv1 = learn.ops.conv2d(X, n_filters=32, filter_shape=[5, 5],
bias=True, activation=tf.nn.relu)
h_pool1 = max_pool_2x2(h_conv1)
# second conv layer will compute 64 features for each 5x5 patch.
with tf.variable_scope('conv_layer2'):
h_conv2 = learn.ops.conv2d(h_pool1, n_filters=64, filter_shape=[5, 5],
bias=True, activation=tf.nn.relu)
h_pool2 = max_pool_2x2(h_conv2)
# reshape tensor into a batch of vectors
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
# densely connected layer with 1024 neurons.
h_fc1 = learn.ops.dnn(
h_pool2_flat, [1024], activation=tf.nn.relu, dropout=0.5)
return learn.models.logistic_regression(h_fc1, y)
# Training and predicting.
classifier = learn.TensorFlowEstimator(
model_fn=conv_model, n_classes=10, batch_size=100, steps=20000,
learning_rate=0.001)
classifier.fit(mnist.train.images, mnist.train.labels)
score = metrics.accuracy_score(
mnist.test.labels, classifier.predict(mnist.test.images))
print('Accuracy: {0:f}'.format(score))
| apache-2.0 |
matthiasdiener/spack | var/spack/repos/builtin/packages/flit/package.py | 5 | 2269 | ##############################################################################
# Copyright (c) 2013-2018, Lawrence Livermore National Security, LLC.
# Produced at the Lawrence Livermore National Laboratory.
#
# This file is part of Spack.
# Created by Todd Gamblin, [email protected], All rights reserved.
# LLNL-CODE-647188
#
# For details, see https://github.com/spack/spack
# Please also see the NOTICE and LICENSE files for our notice and the LGPL.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License (as
# published by the Free Software Foundation) version 2.1, February 1999.
#
# 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 terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##############################################################################
from spack import *
class Flit(MakefilePackage):
"""Floating-point Litmus Tests (FLiT) is a C++ test infrastructure for
detecting variability in floating-point code caused by variations in
compiler code generation, hardware and execution environments."""
homepage = "https://pruners.github.io/flit"
url = "https://github.com/PRUNERS/FLiT"
url = "https://github.com/PRUNERS/FLiT/archive/v2.0-alpha.1.tar.gz"
version('2.0-alpha.1', '62cf7784bcdc15b962c813b11e478159')
# FIXME: fix install and build to handle the old version, which is not
# installable
# version('1.0.0', '27763c89b044c5e3cfe62dd319a36a2b')
conflicts("@:1.999", msg="Only can build version 2.0 and up")
# Add dependencies
depends_on('python@3:', type='run')
depends_on('py-numpy', type='run')
depends_on('py-matplotlib tk=False', type='run')
depends_on('py-toml', type='run')
@property
def install_targets(self):
return ['install', 'PREFIX=%s' % self.prefix]
| lgpl-2.1 |
karoraw1/GLM_Wrapper | OTU_Time_Series/rarefy.py | 1 | 1197 | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Wed Apr 12 11:38:23 2017
@author: login
"""
import pandas as pd
import numpy as np
def abund_vec_to_list(sp_ser):
sp_list = []
for idx in sp_ser.index:
sp_count = sp_ser.ix[idx]
for cnt in range(int(sp_count)):
sp_list.append(idx)
return np.array(sp_list)
def rarefy_table(otu_table):
"""
Rarefies and otu table (pandas dataframe) to minimum lib size
"""
lib_size = int(otu_table.sum(axis=1).min())
print "Minimum library size is {}".format(lib_size)
data_ = np.zeros(otu_table.shape)
rarefiedTable = pd.DataFrame(data = data_, columns=otu_table.columns,
index=otu_table.index)
for row in otu_table.index:
def add_cnt_to_col(c, n):
rarefiedTable.ix[row, c] = n
return None
sp_ser = otu_table.ix[row, :]
sp_pool = abund_vec_to_list(sp_ser)
shrunk_pool = np.random.choice(sp_pool, size=(1, lib_size), replace=False)
cols, cnts = np.unique(shrunk_pool, return_counts=True)
map(add_cnt_to_col, cols, cnts)
return rarefiedTable
| mit |
vkscool/nupic | external/linux32/lib/python2.6/site-packages/matplotlib/finance.py | 69 | 20558 | """
A collection of modules for collecting, analyzing and plotting
financial data. User contributions welcome!
"""
#from __future__ import division
import os, time, warnings
from urllib import urlopen
try:
from hashlib import md5
except ImportError:
from md5 import md5 #Deprecated in 2.5
try: import datetime
except ImportError:
raise ImportError('The finance module requires datetime support (python2.3)')
import numpy as np
from matplotlib import verbose, get_configdir
from dates import date2num
from matplotlib.cbook import Bunch
from matplotlib.collections import LineCollection, PolyCollection
from matplotlib.colors import colorConverter
from lines import Line2D, TICKLEFT, TICKRIGHT
from patches import Rectangle
from matplotlib.transforms import Affine2D
configdir = get_configdir()
cachedir = os.path.join(configdir, 'finance.cache')
def parse_yahoo_historical(fh, asobject=False, adjusted=True):
"""
Parse the historical data in file handle fh from yahoo finance and return
results as a list of
d, open, close, high, low, volume
where d is a floating poing representation of date, as returned by date2num
if adjust=True, use adjusted prices
"""
results = []
lines = fh.readlines()
datefmt = None
for line in lines[1:]:
vals = line.split(',')
if len(vals)!=7: continue
datestr = vals[0]
if datefmt is None:
try:
datefmt = '%Y-%m-%d'
dt = datetime.date(*time.strptime(datestr, datefmt)[:3])
except ValueError:
datefmt = '%d-%b-%y' # Old Yahoo--cached file?
dt = datetime.date(*time.strptime(datestr, datefmt)[:3])
d = date2num(dt)
open, high, low, close = [float(val) for val in vals[1:5]]
volume = int(vals[5])
if adjusted:
aclose = float(vals[6])
m = aclose/close
open *= m
high *= m
low *= m
close = aclose
results.append((d, open, close, high, low, volume))
results.reverse()
if asobject:
if len(results)==0: return None
else:
date, open, close, high, low, volume = map(np.asarray, zip(*results))
return Bunch(date=date, open=open, close=close, high=high, low=low, volume=volume)
else:
return results
def fetch_historical_yahoo(ticker, date1, date2, cachename=None):
"""
Fetch historical data for ticker between date1 and date2. date1 and
date2 are datetime instances
Ex:
fh = fetch_historical_yahoo('^GSPC', d1, d2)
cachename is the name of the local file cache. If None, will
default to the md5 hash or the url (which incorporates the ticker
and date range)
a file handle is returned
"""
ticker = ticker.upper()
d1 = (date1.month-1, date1.day, date1.year)
d2 = (date2.month-1, date2.day, date2.year)
urlFmt = 'http://table.finance.yahoo.com/table.csv?a=%d&b=%d&c=%d&d=%d&e=%d&f=%d&s=%s&y=0&g=d&ignore=.csv'
url = urlFmt % (d1[0], d1[1], d1[2],
d2[0], d2[1], d2[2], ticker)
if cachename is None:
cachename = os.path.join(cachedir, md5(url).hexdigest())
if os.path.exists(cachename):
fh = file(cachename)
verbose.report('Using cachefile %s for %s'%(cachename, ticker))
else:
if not os.path.isdir(cachedir): os.mkdir(cachedir)
fh = file(cachename, 'w')
fh.write(urlopen(url).read())
fh.close()
verbose.report('Saved %s data to cache file %s'%(ticker, cachename))
fh = file(cachename, 'r')
return fh
def quotes_historical_yahoo(ticker, date1, date2, asobject=False, adjusted=True, cachename=None):
"""
Get historical data for ticker between date1 and date2. date1 and
date2 are datetime instances
results are a list of tuples
(d, open, close, high, low, volume)
where d is a floating poing representation of date, as returned by date2num
if asobject is True, the return val is an object with attrs date,
open, close, high, low, volume, which are equal length arrays
if adjust=True, use adjusted prices
Ex:
sp = f.quotes_historical_yahoo('^GSPC', d1, d2, asobject=True, adjusted=True)
returns = (sp.open[1:] - sp.open[:-1])/sp.open[1:]
[n,bins,patches] = hist(returns, 100)
mu = mean(returns)
sigma = std(returns)
x = normpdf(bins, mu, sigma)
plot(bins, x, color='red', lw=2)
cachename is the name of the local file cache. If None, will
default to the md5 hash or the url (which incorporates the ticker
and date range)
"""
fh = fetch_historical_yahoo(ticker, date1, date2, cachename)
try: ret = parse_yahoo_historical(fh, asobject, adjusted)
except IOError, exc:
warnings.warn('urlopen() failure\n' + url + '\n' + exc.strerror[1])
return None
return ret
def plot_day_summary(ax, quotes, ticksize=3,
colorup='k', colordown='r',
):
"""
quotes is a list of (time, open, close, high, low, ...) tuples
Represent the time, open, close, high, low as a vertical line
ranging from low to high. The left tick is the open and the right
tick is the close.
time must be in float date format - see date2num
ax : an Axes instance to plot to
ticksize : open/close tick marker in points
colorup : the color of the lines where close >= open
colordown : the color of the lines where close < open
return value is a list of lines added
"""
lines = []
for q in quotes:
t, open, close, high, low = q[:5]
if close>=open : color = colorup
else : color = colordown
vline = Line2D(
xdata=(t, t), ydata=(low, high),
color=color,
antialiased=False, # no need to antialias vert lines
)
oline = Line2D(
xdata=(t, t), ydata=(open, open),
color=color,
antialiased=False,
marker=TICKLEFT,
markersize=ticksize,
)
cline = Line2D(
xdata=(t, t), ydata=(close, close),
color=color,
antialiased=False,
markersize=ticksize,
marker=TICKRIGHT)
lines.extend((vline, oline, cline))
ax.add_line(vline)
ax.add_line(oline)
ax.add_line(cline)
ax.autoscale_view()
return lines
def candlestick(ax, quotes, width=0.2, colorup='k', colordown='r',
alpha=1.0):
"""
quotes is a list of (time, open, close, high, low, ...) tuples.
As long as the first 5 elements of the tuples are these values,
the tuple can be as long as you want (eg it may store volume).
time must be in float days format - see date2num
Plot the time, open, close, high, low as a vertical line ranging
from low to high. Use a rectangular bar to represent the
open-close span. If close >= open, use colorup to color the bar,
otherwise use colordown
ax : an Axes instance to plot to
width : fraction of a day for the rectangle width
colorup : the color of the rectangle where close >= open
colordown : the color of the rectangle where close < open
alpha : the rectangle alpha level
return value is lines, patches where lines is a list of lines
added and patches is a list of the rectangle patches added
"""
OFFSET = width/2.0
lines = []
patches = []
for q in quotes:
t, open, close, high, low = q[:5]
if close>=open :
color = colorup
lower = open
height = close-open
else :
color = colordown
lower = close
height = open-close
vline = Line2D(
xdata=(t, t), ydata=(low, high),
color='k',
linewidth=0.5,
antialiased=True,
)
rect = Rectangle(
xy = (t-OFFSET, lower),
width = width,
height = height,
facecolor = color,
edgecolor = color,
)
rect.set_alpha(alpha)
lines.append(vline)
patches.append(rect)
ax.add_line(vline)
ax.add_patch(rect)
ax.autoscale_view()
return lines, patches
def plot_day_summary2(ax, opens, closes, highs, lows, ticksize=4,
colorup='k', colordown='r',
):
"""
Represent the time, open, close, high, low as a vertical line
ranging from low to high. The left tick is the open and the right
tick is the close.
ax : an Axes instance to plot to
ticksize : size of open and close ticks in points
colorup : the color of the lines where close >= open
colordown : the color of the lines where close < open
return value is a list of lines added
"""
# note this code assumes if any value open, close, low, high is
# missing they all are missing
rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(xrange(len(lows)), lows, highs) if low != -1 ]
# the ticks will be from ticksize to 0 in points at the origin and
# we'll translate these to the i, close location
openSegments = [ ((-ticksize, 0), (0, 0)) ]
# the ticks will be from 0 to ticksize in points at the origin and
# we'll translate these to the i, close location
closeSegments = [ ((0, 0), (ticksize, 0)) ]
offsetsOpen = [ (i, open) for i, open in zip(xrange(len(opens)), opens) if open != -1 ]
offsetsClose = [ (i, close) for i, close in zip(xrange(len(closes)), closes) if close != -1 ]
scale = ax.figure.dpi * (1.0/72.0)
tickTransform = Affine2D().scale(scale, 0.0)
r,g,b = colorConverter.to_rgb(colorup)
colorup = r,g,b,1
r,g,b = colorConverter.to_rgb(colordown)
colordown = r,g,b,1
colord = { True : colorup,
False : colordown,
}
colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
assert(len(rangeSegments)==len(offsetsOpen))
assert(len(offsetsOpen)==len(offsetsClose))
assert(len(offsetsClose)==len(colors))
useAA = 0, # use tuple here
lw = 1, # and here
rangeCollection = LineCollection(rangeSegments,
colors = colors,
linewidths = lw,
antialiaseds = useAA,
)
openCollection = LineCollection(openSegments,
colors = colors,
antialiaseds = useAA,
linewidths = lw,
offsets = offsetsOpen,
transOffset = ax.transData,
)
openCollection.set_transform(tickTransform)
closeCollection = LineCollection(closeSegments,
colors = colors,
antialiaseds = useAA,
linewidths = lw,
offsets = offsetsClose,
transOffset = ax.transData,
)
closeCollection.set_transform(tickTransform)
minpy, maxx = (0, len(rangeSegments))
miny = min([low for low in lows if low !=-1])
maxy = max([high for high in highs if high != -1])
corners = (minpy, miny), (maxx, maxy)
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
ax.add_collection(rangeCollection)
ax.add_collection(openCollection)
ax.add_collection(closeCollection)
return rangeCollection, openCollection, closeCollection
def candlestick2(ax, opens, closes, highs, lows, width=4,
colorup='k', colordown='r',
alpha=0.75,
):
"""
Represent the open, close as a bar line and high low range as a
vertical line.
ax : an Axes instance to plot to
width : the bar width in points
colorup : the color of the lines where close >= open
colordown : the color of the lines where close < open
alpha : bar transparency
return value is lineCollection, barCollection
"""
# note this code assumes if any value open, close, low, high is
# missing they all are missing
delta = width/2.
barVerts = [ ( (i-delta, open), (i-delta, close), (i+delta, close), (i+delta, open) ) for i, open, close in zip(xrange(len(opens)), opens, closes) if open != -1 and close!=-1 ]
rangeSegments = [ ((i, low), (i, high)) for i, low, high in zip(xrange(len(lows)), lows, highs) if low != -1 ]
r,g,b = colorConverter.to_rgb(colorup)
colorup = r,g,b,alpha
r,g,b = colorConverter.to_rgb(colordown)
colordown = r,g,b,alpha
colord = { True : colorup,
False : colordown,
}
colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
assert(len(barVerts)==len(rangeSegments))
useAA = 0, # use tuple here
lw = 0.5, # and here
rangeCollection = LineCollection(rangeSegments,
colors = ( (0,0,0,1), ),
linewidths = lw,
antialiaseds = useAA,
)
barCollection = PolyCollection(barVerts,
facecolors = colors,
edgecolors = ( (0,0,0,1), ),
antialiaseds = useAA,
linewidths = lw,
)
minx, maxx = 0, len(rangeSegments)
miny = min([low for low in lows if low !=-1])
maxy = max([high for high in highs if high != -1])
corners = (minx, miny), (maxx, maxy)
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
ax.add_collection(barCollection)
ax.add_collection(rangeCollection)
return rangeCollection, barCollection
def volume_overlay(ax, opens, closes, volumes,
colorup='k', colordown='r',
width=4, alpha=1.0):
"""
Add a volume overlay to the current axes. The opens and closes
are used to determine the color of the bar. -1 is missing. If a
value is missing on one it must be missing on all
ax : an Axes instance to plot to
width : the bar width in points
colorup : the color of the lines where close >= open
colordown : the color of the lines where close < open
alpha : bar transparency
"""
r,g,b = colorConverter.to_rgb(colorup)
colorup = r,g,b,alpha
r,g,b = colorConverter.to_rgb(colordown)
colordown = r,g,b,alpha
colord = { True : colorup,
False : colordown,
}
colors = [colord[open<close] for open, close in zip(opens, closes) if open!=-1 and close !=-1]
delta = width/2.
bars = [ ( (i-delta, 0), (i-delta, v), (i+delta, v), (i+delta, 0)) for i, v in enumerate(volumes) if v != -1 ]
barCollection = PolyCollection(bars,
facecolors = colors,
edgecolors = ( (0,0,0,1), ),
antialiaseds = (0,),
linewidths = (0.5,),
)
corners = (0, 0), (len(bars), max(volumes))
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
return barCollection
def volume_overlay2(ax, closes, volumes,
colorup='k', colordown='r',
width=4, alpha=1.0):
"""
Add a volume overlay to the current axes. The closes are used to
determine the color of the bar. -1 is missing. If a value is
missing on one it must be missing on all
ax : an Axes instance to plot to
width : the bar width in points
colorup : the color of the lines where close >= open
colordown : the color of the lines where close < open
alpha : bar transparency
nb: first point is not displayed - it is used only for choosing the
right color
"""
return volume_overlay(ax,closes[:-1],closes[1:],volumes[1:],colorup,colordown,width,alpha)
def volume_overlay3(ax, quotes,
colorup='k', colordown='r',
width=4, alpha=1.0):
"""
Add a volume overlay to the current axes. quotes is a list of (d,
open, close, high, low, volume) and close-open is used to
determine the color of the bar
kwarg
width : the bar width in points
colorup : the color of the lines where close1 >= close0
colordown : the color of the lines where close1 < close0
alpha : bar transparency
"""
r,g,b = colorConverter.to_rgb(colorup)
colorup = r,g,b,alpha
r,g,b = colorConverter.to_rgb(colordown)
colordown = r,g,b,alpha
colord = { True : colorup,
False : colordown,
}
dates, opens, closes, highs, lows, volumes = zip(*quotes)
colors = [colord[close1>=close0] for close0, close1 in zip(closes[:-1], closes[1:]) if close0!=-1 and close1 !=-1]
colors.insert(0,colord[closes[0]>=opens[0]])
right = width/2.0
left = -width/2.0
bars = [ ( (left, 0), (left, volume), (right, volume), (right, 0)) for d, open, close, high, low, volume in quotes]
sx = ax.figure.dpi * (1.0/72.0) # scale for points
sy = ax.bbox.height / ax.viewLim.height
barTransform = Affine2D().scale(sx,sy)
dates = [d for d, open, close, high, low, volume in quotes]
offsetsBars = [(d, 0) for d in dates]
useAA = 0, # use tuple here
lw = 0.5, # and here
barCollection = PolyCollection(bars,
facecolors = colors,
edgecolors = ( (0,0,0,1), ),
antialiaseds = useAA,
linewidths = lw,
offsets = offsetsBars,
transOffset = ax.transData,
)
barCollection.set_transform(barTransform)
minpy, maxx = (min(dates), max(dates))
miny = 0
maxy = max([volume for d, open, close, high, low, volume in quotes])
corners = (minpy, miny), (maxx, maxy)
ax.update_datalim(corners)
#print 'datalim', ax.dataLim.get_bounds()
#print 'viewlim', ax.viewLim.get_bounds()
ax.add_collection(barCollection)
ax.autoscale_view()
return barCollection
def index_bar(ax, vals,
facecolor='b', edgecolor='l',
width=4, alpha=1.0, ):
"""
Add a bar collection graph with height vals (-1 is missing).
ax : an Axes instance to plot to
width : the bar width in points
alpha : bar transparency
"""
facecolors = (colorConverter.to_rgba(facecolor, alpha),)
edgecolors = (colorConverter.to_rgba(edgecolor, alpha),)
right = width/2.0
left = -width/2.0
bars = [ ( (left, 0), (left, v), (right, v), (right, 0)) for v in vals if v != -1 ]
sx = ax.figure.dpi * (1.0/72.0) # scale for points
sy = ax.bbox.height / ax.viewLim.height
barTransform = Affine2D().scale(sx,sy)
offsetsBars = [ (i, 0) for i,v in enumerate(vals) if v != -1 ]
barCollection = PolyCollection(bars,
facecolors = facecolors,
edgecolors = edgecolors,
antialiaseds = (0,),
linewidths = (0.5,),
offsets = offsetsBars,
transOffset = ax.transData,
)
barCollection.set_transform(barTransform)
minpy, maxx = (0, len(offsetsBars))
miny = 0
maxy = max([v for v in vals if v!=-1])
corners = (minpy, miny), (maxx, maxy)
ax.update_datalim(corners)
ax.autoscale_view()
# add these last
ax.add_collection(barCollection)
return barCollection
| gpl-3.0 |
rishikksh20/scikit-learn | sklearn/feature_selection/__init__.py | 140 | 1302 | """
The :mod:`sklearn.feature_selection` module implements feature selection
algorithms. It currently includes univariate filter selection methods and the
recursive feature elimination algorithm.
"""
from .univariate_selection import chi2
from .univariate_selection import f_classif
from .univariate_selection import f_oneway
from .univariate_selection import f_regression
from .univariate_selection import SelectPercentile
from .univariate_selection import SelectKBest
from .univariate_selection import SelectFpr
from .univariate_selection import SelectFdr
from .univariate_selection import SelectFwe
from .univariate_selection import GenericUnivariateSelect
from .variance_threshold import VarianceThreshold
from .rfe import RFE
from .rfe import RFECV
from .from_model import SelectFromModel
from .mutual_info_ import mutual_info_regression, mutual_info_classif
__all__ = ['GenericUnivariateSelect',
'RFE',
'RFECV',
'SelectFdr',
'SelectFpr',
'SelectFwe',
'SelectKBest',
'SelectFromModel',
'SelectPercentile',
'VarianceThreshold',
'chi2',
'f_classif',
'f_oneway',
'f_regression',
'mutual_info_classif',
'mutual_info_regression']
| bsd-3-clause |
florian-f/sklearn | examples/mixture/plot_gmm.py | 18 | 2796 | """
=================================
Gaussian Mixture Model Ellipsoids
=================================
Plot the confidence ellipsoids of a mixture of two gaussians with EM
and variational dirichlet process.
Both models have access to five components with which to fit the
data. Note that the EM model will necessarily use all five components
while the DP model will effectively only use as many as are needed for
a good fit. This is a property of the Dirichlet Process prior. Here we
can see that the EM model splits some components arbitrarily, because it
is trying to fit too many components, while the Dirichlet Process model
adapts it number of state automatically.
This example doesn't show it, as we're in a low-dimensional space, but
another advantage of the dirichlet process model is that it can fit
full covariance matrices effectively even when there are less examples
per cluster than there are dimensions in the data, due to
regularization properties of the inference algorithm.
"""
import itertools
import numpy as np
from scipy import linalg
import pylab as pl
import matplotlib as mpl
from sklearn import mixture
# Number of samples per component
n_samples = 500
# Generate random sample, two components
np.random.seed(0)
C = np.array([[0., -0.1], [1.7, .4]])
X = np.r_[np.dot(np.random.randn(n_samples, 2), C),
.7 * np.random.randn(n_samples, 2) + np.array([-6, 3])]
# Fit a mixture of gaussians with EM using five components
gmm = mixture.GMM(n_components=5, covariance_type='full')
gmm.fit(X)
# Fit a dirichlet process mixture of gaussians using five components
dpgmm = mixture.DPGMM(n_components=5, covariance_type='full')
dpgmm.fit(X)
color_iter = itertools.cycle(['r', 'g', 'b', 'c', 'm'])
for i, (clf, title) in enumerate([(gmm, 'GMM'),
(dpgmm, 'Dirichlet Process GMM')]):
splot = pl.subplot(2, 1, 1 + i)
Y_ = clf.predict(X)
for i, (mean, covar, color) in enumerate(zip(
clf.means_, clf._get_covars(), color_iter)):
v, w = linalg.eigh(covar)
u = w[0] / linalg.norm(w[0])
# as the DP will not use every component it has access to
# unless it needs it, we shouldn't plot the redundant
# components.
if not np.any(Y_ == i):
continue
pl.scatter(X[Y_ == i, 0], X[Y_ == i, 1], .8, color=color)
# Plot an ellipse to show the Gaussian component
angle = np.arctan(u[1] / u[0])
angle = 180 * angle / np.pi # convert to degrees
ell = mpl.patches.Ellipse(mean, v[0], v[1], 180 + angle, color=color)
ell.set_clip_box(splot.bbox)
ell.set_alpha(0.5)
splot.add_artist(ell)
pl.xlim(-10, 10)
pl.ylim(-3, 6)
pl.xticks(())
pl.yticks(())
pl.title(title)
pl.show()
| bsd-3-clause |
asazo/ANN | tarea2/2_script.py | 1 | 10170 | # -*- coding: utf-8 -*-
import os
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
from keras.utils import np_utils
def unpickle(file):
import cPickle
fo = open(file, 'rb')
dict = cPickle.load(fo)
fo.close()
return dict
def load_single_NORB_train_val(PATH, i, onlyx=False):
print "Cargando batch training set",i,"..."
f = os.path.join(PATH, 'data_batch_%d' % (i, ))
datadict = unpickle(f)
X = datadict['data'].T
Y = np.array(datadict['labels'])
Z = np.zeros((X.shape[0], X.shape[1] + 1))
Z[:,:-1] = X
Z[:, -1] = Y
np.random.shuffle(Z)
if onlyx:
Xtr = Z[5832:,0:-1]
return Xtr
else:
Xtr = Z[5832:,0:-1]
Ytr = Z[5832:,-1]
Xval = Z[:5832,0:-1]
Yval = Z[:5832,-1]
print "Cargado"
return Xtr, Ytr, Xval, Yval
def load_NORB_test(PATH):
print "Cargando testing set..."
xts = []
yts = []
for b in range(11, 13):
f = os.path.join(PATH, 'data_batch_%d' % (b, ))
datadict = unpickle(f)
X = datadict['data'].T
Y = np.array(datadict['labels'])
Z = np.zeros((X.shape[0], X.shape[1] + 1))
Z[:,:-1] = X
Z[:, -1] = Y
np.random.shuffle(Z)
xts.append(Z[0:,0:-1])
yts.append(Z[:,-1])
Xts = np.concatenate(xts)
Yts = np.concatenate(yts)
del xts,yts
print "Cargado."
return Xts, Yts
def scale_data(X, normalize=True, myrange=None):
from sklearn.preprocessing import MinMaxScaler, StandardScaler
if normalize and not myrange:
print "Normalizando data (mean 0, std 1)"
return StandardScaler().fit_transform(X)
elif isinstance(myrange, tuple):
print "Escalando data al rango", myrange
return X * (myrange[1] - myrange[0]) + myrange[0]
else:
return "Error mientras escalaba."
# Modelo MLP FF
def get_ff_model(activation, n_classes):
model = Sequential()
model.add(Dense(4000, input_dim=2048, activation=activation))
model.add(Dense(2000, activation=activation))
model.add(Dense(n_classes, activation='softmax'))
sgd = SGD(lr=0.1, decay=0.0)
model.compile(optimizer=sgd,
loss='binary_crossentropy',
metrics=['accuracy'])
return model
# Definir numero de clases
n_classes = 6
Xts, Yts = load_NORB_test(".")
Xts_scaled = scale_data(Xts)
Yts_class = np_utils.to_categorical(Yts.astype(int), n_classes)
# Experimento: error de pruebas en funcion de theta (proporcion data no supervisada)
# Entrenar por porcentajes conocidos implica iterativamente avanzar batch sobre batch...
accuracies = []
model = get_ff_model('relu', n_classes)
print "Metricas:",model.metrics_names
for i, theta in enumerate(np.linspace(0.1, 1, 10)):
print "Analizando theta =",theta
print "Utilizando",i+1,"batches de 10"
Xtr, Ytr, Xval, Yval = load_single_NORB_train_val(".", i+1)
n_tr = Xtr.shape[0]
# Escalar datos y categorizar
print "Escalando data..."
Xtr_scaled = scale_data(Xtr)
Xval_scaled = scale_data(Xval)
print "Data escalada."
print "Pasando a data categorica para labels..."
Ytr_class = np_utils.to_categorical(Ytr.astype(int), n_classes)
Yval_class = np_utils.to_categorical(Yval.astype(int), n_classes)
print "Data categorizada."
model.fit(Xtr_scaled, Ytr_class, batch_size=10, validation_data=(Xval_scaled, Yval_class), nb_epoch=1)
print "Batch entrenado."
a = model.evaluate(Xts_scaled, Yts_class, batch_size=10, verbose=1)
print "Resultado:",a
accuracies.append(a)
print accuracies
from sklearn.neural_network import BernoulliRBM
from sklearn.externals import joblib
from keras.layers import Input, Dense
from keras.models import Model
from keras.optimizers import SGD
# Pre entrenar con RBM
RBM1 = BernoulliRBM(n_components=512, batch_size=10,
learning_rate=0.01, verbose=1, n_iter=30)
RBM2 = BernoulliRBM(n_components=100, batch_size=10,
learning_rate=0.01, verbose=1, n_iter=30)
for i, rev_theta in enumerate(np.linspace(0.1, 1, 10)):
theta = 1 - rev_theta
print "Preentrenando modelo para theta=",theta
print "Leyendo batch",i+1
Xtr_ns = load_single_NORB_train_val(".", i+1, onlyx=True)
Xtr_ns = scale_data(Xtr_ns)
RBM1.partial_fit(Xtr_ns)
Xtr_ns2 = RBM1.transform(Xtr_ns)
print "..."
Xtr_ns2 = scale_data(Xtr_ns2)
RBM2.partial_fit(Xtr_ns2)
del Xtr_ns, Xtr_ns2
print "..."
joblib.dump(RBM1, "2/RBM1_512_"+str(theta)+".pkl")
joblib.dump(RBM2, "2/RBM2_512_"+str(theta)+".pkl")
# Entrenar usando RBM
accuracies = []
activation = 'tanh'
for i, theta in enumerate(np.linspace(0.1, 1, 10)):
print "Analizando theta =",theta
if i != 9:
print "Cargando rbms"
RBM1 = joblib.load('2/RBM1_512_'+str(theta)+".pkl")
RBM2 = joblib.load('2/RBM2_512_'+str(theta)+".pkl")
model = Sequential()
model.add(Dense(512, input_dim=2048, activation=activation))
if i != 9:
print "seteando pesos 1"
model.layers[-1].set_weights([RBM1.components_.T, RBM1.intercept_hidden_])
model.add(Dense(100, activation=activation))
if i != 9:
print "seteando pesos 2"
model.layers[-1].set_weights([RBM2.components_.T, RBM2.intercept_hidden_])
model.add(Dense(n_classes, activation='softmax'))
sgd = SGD(lr=0.1, decay=0.0)
model.compile(optimizer=sgd,
loss='binary_crossentropy',
metrics=['accuracy'])
print "Entrenando..."
for n in range(2):
for k in range(0, i+1):
print "Leyendo batch",k
Xtr, Ytr, Xval, Yval = load_single_NORB_train_val(".", k+1)
# Escalar datos y categorizar
print "Escalando data..."
Xtr_scaled = scale_data(Xtr)
Xval_scaled = scale_data(Xval)
print "Data escalada."
print "Pasando a data categorica para labels..."
Ytr_class = np_utils.to_categorical(Ytr.astype(int), n_classes)
Yval_class = np_utils.to_categorical(Yval.astype(int), n_classes)
print "Data categorizada."
model.fit(Xtr_scaled, Ytr_class, batch_size=10,
validation_data=(Xval_scaled, Yval_class), nb_epoch=1)
print "Batch entrenado."
a = model.evaluate(Xts_scaled, Yts_class, batch_size=10, verbose=1)
print "Resultado:",a
accuracies.append(a)
print accuracies
del Xtr, Ytr, Xval, Yval
print accuracies
# Preentrenamiento con AE
hidden_layer = 512
hidden_layer2 = 100
activation1 = 'relu'
activation2 = 'sigmoid'
input_img1 = Input(shape=(2048,))
encoded1 = Dense(hidden_layer, activation=activation1)(input_img1)
decoded1 = Dense(2048, activation=activation2)(encoded1)
autoencoder1 = Model(input=input_img1, output=decoded1)
encoder1 = Model(input=input_img1, output=encoded1)
autoencoder1.compile(optimizer=SGD(lr=0.001), loss='binary_crossentropy')
input_img2 = Input(shape=(hidden_layer,))
encoded2 = Dense(hidden_layer2, activation=activation2)(input_img2)
decoded2 = Dense(hidden_layer, activation=activation2)(encoded2)
autoencoder2 = Model(input=input_img2, output=decoded2)
encoder2 = Model(input=input_img2, output=encoded2)
autoencoder2.compile(optimizer=SGD(lr=0.001), loss='binary_crossentropy')
for i, rev_theta in enumerate(np.linspace(0.1, 0.9, 9)):
theta = 1 - rev_theta
print "Preentrenando modelo para theta=",theta
print "Leyendo batch",i+1
Xtr_ns, Ytr_ns, Xval_ns, Yval_ns = load_single_NORB_train_val(".", i+1)
Xtr_ns = scale_data(Xtr_ns)
Xval_ns = scale_data(Xval_ns)
autoencoder1.fit(Xtr_ns, Xtr_ns, nb_epoch=10, batch_size=250,shuffle=True, validation_data=(Xval_ns, Xval_ns))
autoencoder1.save('2/AE1_'+str(theta)+'.h5')
encoder1.save('2/E1_'+str(theta)+'.h5')
Xtr_ns_1 = encoder1.predict(Xtr_ns)
Xval_ns_1 = encoder1.predict(Xval_ns)
autoencoder2.fit(Xtr_ns_1,Xtr_ns_1,nb_epoch=10,batch_size=250, shuffle=True, validation_data=(Xval_ns_1, Xval_ns_1))
autoencoder2.save('2/AE2_'+str(theta)+'.h5')
encoder2.save('2/E2_'+str(theta)+'.h5')
accuracies = []
activation = 'tanh'
from keras.models import load_model
for i, theta in enumerate(np.linspace(0.1, 1, 10)):
print "Analizando theta =",theta
if i != 9:
AE1 = load_model('2/AEpretraining512/AE1_'+str(theta)+".h5")
AE2 = load_model('2/AEpretraining512/AE2_'+str(theta)+".h5")
model = Sequential()
model.add(Dense(hidden_layer, input_dim=2048, activation=activation))
if i != 9:
print "setear pesos 1"
model.layers[-1].set_weights(AE1.layers[1].get_weights())
model.add(Dense(hidden_layer2, activation=activation))
if i != 9:
print "setear pesos 2"
model.layers[-1].set_weights(AE2.layers[1].get_weights())
model.add(Dense(n_classes, activation='softmax'))
sgd = SGD(lr=0.1, decay=0.0)
model.compile(optimizer=sgd,
loss='binary_crossentropy',
metrics=['accuracy'])
print "Entrenando..."
for n in range(2):
for k in range(0, i+1):
print "Leyendo batch",k
Xtr, Ytr, Xval, Yval = load_single_NORB_train_val(".", k+1)
# Escalar datos y categorizar
print "Escalando data..."
Xtr_scaled = scale_data(Xtr)
Xval_scaled = scale_data(Xval)
print "Data escalada."
print "Pasando a data categorica para labels..."
Ytr_class = np_utils.to_categorical(Ytr.astype(int), n_classes)
Yval_class = np_utils.to_categorical(Yval.astype(int), n_classes)
print "Data categorizada."
model.fit(Xtr_scaled, Ytr_class, batch_size=10,
validation_data=(Xval_scaled, Yval_class), nb_epoch=1)
print "Batch entrenado."
a = model.evaluate(Xts_scaled, Yts_class, batch_size=10, verbose=1)
print "Resultado:",a
accuracies.append(a)
print accuracies
del Xtr, Ytr, Xval, Yval
print accuracies
| mit |
bbfamily/abu | abupy/SimilarBu/ABuSimilar.py | 1 | 22856 | # -*- encoding:utf-8 -*-
"""
相关系数相似应用模块
"""
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
import functools
import logging
import math
import operator
import os
import pandas as pd
from . import ABuCorrcoef
from . import ABuSimilarDrawing
from .ABuCorrcoef import ECoreCorrType
from ..TradeBu import AbuBenchmark
from ..CoreBu import ABuEnv
from ..CoreBu.ABuParallel import delayed, Parallel
from ..CoreBu.ABuEnv import EMarketDataSplitMode, EMarketTargetType
from ..MarketBu import ABuSymbolPd
from ..MarketBu.ABuMarket import split_k_market, all_symbol
from ..MarketBu.ABuSymbol import IndexSymbol, Symbol
from ..UtilBu.ABuDTUtil import consume_time
from ..UtilBu.ABuProgress import do_clear_output
from ..CoreBu.ABuEnvProcess import add_process_env_sig, AbuEnvProcess
# noinspection PyUnresolvedReferences
from ..CoreBu.ABuFixes import xrange
from ..UtilBu import ABuProgress
"""进行相似度数据收集并行进程数，IO操作偏多，所以分配多个，默认=cpu个数＊2, windows还是..."""
g_process_panel_cnt = ABuEnv.g_cpu_cnt * 2 if ABuEnv.g_is_mac_os else ABuEnv.g_cpu_cnt
def from_local(func):
"""
现所有相似度应用默认为from_local模式，即需要在有数据的情况下做相似度应用
为进行相似度数据收集的函数装饰，作用是忽略env中的数据获取模式，改变数据获取模式，
只使用本地数据模式进行数据收集，完成整个任务后，再恢复之前的数据获取模式
:param func: 进行相似度应用且有数据收集行为的函数
"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
# 临时保存env设置中的g_data_fetch_mode
fetch_mode = ABuEnv.g_data_fetch_mode
# 设置数据获取模式为强制本地缓存模式
ABuEnv.g_data_fetch_mode = ABuEnv.EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
if fetch_mode != ABuEnv.EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL:
# 如果原有设置不是强制本地缓存模式，warning提示
logging.warning('data from local. run ABu.run_kl_update if you want to get the latest data.')
result = func(*args, **kwargs)
# 恢复之前的g_data_fetch_mode
ABuEnv.g_data_fetch_mode = fetch_mode
return result
return wrapper
def from_net(func):
"""
为进行相似度数据收集的函数装饰，作用是忽略env中的数据获取模式，改变数据获取模式，
只使用网络数据模式进行数据收集，完成整个任务后，再恢复之前的数据获取模式
:param func: 进行相似度应用且有数据收集行为的函数
"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
# 临时保存env设置中的g_data_fetch_mode
fetch_mode = ABuEnv.g_data_fetch_mode
# 设置数据获取模式为强制网络模式
ABuEnv.g_data_fetch_mode = ABuEnv.EMarketDataFetchMode.E_DATA_FETCH_FORCE_NET
if fetch_mode != ABuEnv.EMarketDataFetchMode.E_DATA_FETCH_FORCE_NET:
# 如果原有设置不是强制网络模式，warning提示
logging.warning('data from net!!!')
result = func(*args, **kwargs)
# 恢复之前的g_data_fetch_mode
ABuEnv.g_data_fetch_mode = fetch_mode
return result
return wrapper
@from_local
def _find_similar(symbol, cmp_cnt=None, n_folds=2, start=None, end=None, show_cnt=None, rolling=False,
show=True, corr_type=ECoreCorrType.E_CORE_TYPE_PEARS):
"""
被from_local装饰器装饰 即强制走本地数据，获取全市场symbol涨跌幅度pd.DataFrame对象，
使用symbol涨跌幅度与全市场symbol涨跌幅度进行相关对比，可视化结果及信息
:param symbol: 外部指定目标symbol，str对象
:param cmp_cnt: 相关性对比多少个交易日，int，可选参数
:param n_folds: 相关性对比n_folds年，int，可选参数
:param start: 请求的开始日期str对象，可选参数
:param end: 请求的结束日期str对象，可选参数
:param show_cnt: 最终结果展示以及可视化相似度个数
:param rolling: 是否使用时间加权相关计算，与corr_type=ECoreCorrType.E_CORE_TYPE_ROLLING一样，单独拿出来了
:param show: 是否可视化最终top最相关的股票
:param corr_type: ECoreCorrType对象，暂时支持皮尔逊，斯皮尔曼，＋－符号相关系数，移动时间加权相关系数
"""
if isinstance(symbol, Symbol):
# 如果传递的时Symbol对象，取value
symbol = symbol.value
# 获取全市场symbol涨跌幅度pd.DataFrame对象
market_change_df = _all_market_cg(symbol, cmp_cnt=cmp_cnt, n_folds=n_folds, start=start, end=end)
if market_change_df is None:
logging.info('{} data is miss, please update data first!'.format(symbol))
return
# 重新赋予标尺实际的交易日数量
cmp_cnt = market_change_df[symbol].shape[0]
# symbol涨跌幅度df数据
benchmark_df = market_change_df[symbol]
# 清一下输出，太乱
do_clear_output()
# 开始使用symbol涨跌幅度与全市场symbol涨跌幅度进行相关对比，可视化结果及信息
sorted_corr = _handle_market_change_df(market_change_df, cmp_cnt, benchmark_df, show_cnt,
corr_type, rolling, show)
return sorted_corr
def find_similar_with_se(symbol, start, end, show_cnt=10, rolling=False, show=True,
corr_type=ECoreCorrType.E_CORE_TYPE_PEARS):
"""
固定参数使用start, end参数提供时间范围规则，套接_find_similar，为_find_similar提供时间范围规则
:param symbol: 外部指定目标symbol，str对象
:param start: 请求的开始日期str对象
:param end: 请求的结束日期str对象
:param show_cnt: 最终结果展示以及可视化相似度个数
:param rolling: 是否使用时间加权相关计算，与corr_type=ECoreCorrType.E_CORE_TYPE_ROLLING一样，单独拿出来了
:param show: 是否可视化最终top最相关的股票
:param corr_type: ECoreCorrType对象，暂时支持皮尔逊，斯皮尔曼，＋－符号相关系数，移动时间加权相关系数
:return:
"""
return _find_similar(symbol, start=start, end=end, show_cnt=show_cnt, rolling=rolling, show=show,
corr_type=corr_type)
def find_similar_with_folds(symbol, n_folds=2, show_cnt=10, rolling=False, show=True,
corr_type=ECoreCorrType.E_CORE_TYPE_PEARS):
"""
固定参数使用n_folds参数提供时间范围规则，套接_find_similar，为_find_similar提供时间范围规则
:param symbol: 外部指定目标symbol，str对象
:param n_folds: 相关性对比n_folds年，int
:param show_cnt: 最终结果展示以及可视化相似度个数
:param rolling: 是否使用时间加权相关计算，与corr_type=ECoreCorrType.E_CORE_TYPE_ROLLING一样，单独拿出来了
:param show: 是否可视化最终top最相关的股票
:param corr_type: ECoreCorrType对象，暂时支持皮尔逊，斯皮尔曼，＋－符号相关系数，移动时间加权相关系数
:return:
"""
return _find_similar(symbol, n_folds=n_folds, show_cnt=show_cnt, rolling=rolling, show=show,
corr_type=corr_type)
def find_similar_with_cnt(symbol, cmp_cnt=60, show_cnt=10, rolling=False, show=True,
corr_type=ECoreCorrType.E_CORE_TYPE_PEARS):
"""
固定参数使用cmp_cnt参数提供时间范围规则，套接_find_similar，为_find_similar提供时间范围规则
:param symbol: 外部指定目标symbol，str对象
:param cmp_cnt: 相关性对比多少个交易日，int
:param show_cnt: 最终结果展示以及可视化相似度个数
:param rolling: 是否使用时间加权相关计算，与corr_type=ECoreCorrType.E_CORE_TYPE_ROLLING一样，单独拿出来了
:param show: 是否可视化最终top最相关的股票
:param corr_type: ECoreCorrType对象，暂时支持皮尔逊，斯皮尔曼，＋－符号相关系数，移动时间加权相关系数
:return:
"""
return _find_similar(symbol, cmp_cnt=cmp_cnt, show_cnt=show_cnt, rolling=rolling, show=show,
corr_type=corr_type)
@add_process_env_sig
def _make_symbols_cg_df(symbols, benchmark):
"""
相关性金融数据收集，子进程委托函数，子进程通过make_kl_df完成主进程委托的symbols个
金融数据收集工作，最终返回所有金融时间序列涨跌幅度pd.DataFrame对象
:param symbols: 可迭代symbols序列，序列中的元素为str对象
:param benchmark: 进行数据收集使用的标尺对象，数据时间范围确定使用，AbuBenchmark实例对象
:return: 所有金融时间序列涨跌幅度pd.DataFrame对象
"""
# 子进程金融数据收集工作, 由于本事是在子进程内工作，所以不再make_kl_df中使用parallel模式，上层进行多任务分配及任务数确定
panel = ABuSymbolPd.make_kl_df(symbols, data_mode=EMarketDataSplitMode.E_DATA_SPLIT_UNDO, benchmark=benchmark,
show_progress=True)
if panel is None or panel.empty:
logging.info('pid {} panel is None'.format(os.getpid()))
return None
# 转换panel轴方向，即可方便获取所有金融时间数据的某一个列
panel = panel.swapaxes('items', 'minor')
net_cg_df = panel['p_change'].fillna(value=0)
"""
转轴后直接获取p_change，即所有金融时间序列涨跌幅度pd.DataFrame对象，形如下所示：
usF usFCAU usGM usHMC usTM usTSLA usTTM
2015-06-25 -0.387 -0.517 -1.308 0.522 -0.391 1.365 -0.029
2015-06-26 -0.259 1.300 -0.922 0.366 0.437 -0.632 -0.229
2015-06-29 -2.468 -6.799 -3.345 -2.676 -2.222 -1.898 -2.550
2015-06-30 -0.067 0.000 0.301 1.250 0.982 2.381 1.353
2015-07-01 -0.133 0.688 -0.870 -1.605 -0.112 0.332 0.261
.................................................................
"""
return net_cg_df
def _make_benchmark_cg_df(symbol, benchmark):
"""
根据benchmark提取其时间序列对象kl_pd中的p_change列，返回p_change组成的
新pd.DataFrame对象，行序列名即为symbol
:param symbol: 标尺对象symbol，str对象
:param benchmark: 进行数据收集使用的标尺对象，数据时间范围确定使用，AbuBenchmark实例对象
:return: 返回p_change组成的新pd.DataFrame对象
"""
kl_pd = benchmark.kl_pd
net_cg_df = pd.DataFrame({symbol: kl_pd['p_change']}, index=kl_pd.index).fillna(value=0)
"""
p_change组成的新pd.DataFrame对象，行序列名即为symbol, 形如下所示：
us.IXIC
2014-07-25 -0.50
2014-07-28 -0.10
2014-07-29 -0.05
2014-07-30 0.45
2014-07-31 -2.09
2014-08-01 -0.39
2014-08-04 0.72
"""
return net_cg_df
def _net_cg_df_create(symbol, benchmark):
"""
获取env中全市场symbol，切分分配子进程，委托子进程_make_symbols_cg_df函数，
将子进程返回的金融时间序列涨跌幅度pd.DataFrame对象再次进行连接，组合成为全市场
symbol涨跌幅度pd.DataFrame对象
:param symbol: 标尺对象symbol，str对象
:param benchmark: 进行数据收集使用的标尺对象，数据时间范围确定使用，AbuBenchmark实例对象
:return: 全市场symbol涨跌幅度pd.DataFrame对象
"""
# 获取全市场symbol，没有指定市场参数，即根据env中设置的市场来获取所有市场symbol
choice_symbols = all_symbol()
# 通过split_k_market将市场symbol切割为子进程需要完成的任务数量
process_symbols = split_k_market(g_process_panel_cnt, market_symbols=choice_symbols)
# 因为切割会有余数，所以将原始设置的进程数切换为分割好的个数, 即32 -> 33 16 -> 17
n_process_pick_stock = len(process_symbols)
parallel = Parallel(
n_jobs=n_process_pick_stock, verbose=0, pre_dispatch='2*n_jobs')
# 暂时关闭多进程进度条，太多, 注意这种全局设置一定要在AbuEnvProcess初始化之前完成
# ABuProgress.g_show_ui_progress = False
# _make_symbols_cg_df被装饰器add_process_env_sig装饰，需要进程间内存拷贝对象AbuEnvProcess, 详AbuEnvProcess
p_nev = AbuEnvProcess()
change_df_array = parallel(
delayed(_make_symbols_cg_df)(choice_symbols, benchmark, env=p_nev) for choice_symbols in process_symbols)
# ABuProgress.g_show_ui_progress = True
# 还是显示进度条，但是完事时检测一下还有没有ui进度条
ABuProgress.do_check_process_is_dead()
"""
如果标尺的涨跌幅已经在choice_symbols中就不单独获取组装了，没有的情况是如：
eg. env中指定市场参数港股，即g_market_target = EMarketTargetType.E_MARKET_TARGET_HK，但是
传人的symbol是a股市场中的一支股票，即目的是想从整个港股市场中分析与这支a股股票的相关系数，这时即会
触发_make_benchmark_cg_df的使用
"""
change_df_concat = None if symbol in choice_symbols else _make_benchmark_cg_df(symbol, benchmark)
for change_df in change_df_array:
if change_df is not None:
# 将所有子进程返回的金融时间序列涨跌幅度pd.DataFrame对象再次进行连接
change_df_concat = change_df if change_df_concat is None else pd.concat([change_df, change_df_concat],
axis=1)
return change_df_concat
@consume_time
def _all_market_cg(symbol, cmp_cnt=None, n_folds=2, start=None, end=None):
"""
获取全市场symbol涨跌幅度pd.DataFrame对象
:param symbol: 外部指定目标symbol，str对象
:param cmp_cnt: 对比多少个交易日，int，可选参数
:param n_folds: 对比n_folds年，int，可选参数
:param start: 请求的开始日期 str对象，可选参数
:param end: 请求的结束日期 str对象，可选参数
:return: 全市场symbol涨跌幅度pd.DataFrame对象, 形如下所示：
e.g.
usA usAA usAAC
2015/7/27 0.76 -1.94 0.59
2015/7/28 2.12 2.6 1.3
2015/7/29 -0.12 2.94 -1.34
2015/7/30 1.41 -1.77 -4.04
2015/7/31 -0.05 -1.1 1.39
"""
if cmp_cnt is not None:
# 如果有传递对比多少个交易日这个参数，即反向修改n_folds，ceil向上对齐金融序列获取年数
n_folds = int(math.ceil(cmp_cnt / ABuEnv.g_market_trade_year))
# 标尺不是使用大盘symbol，而是传人的symbol做为标尺
benchmark = AbuBenchmark(benchmark=symbol, n_folds=n_folds, start=start, end=end, rs=False)
if benchmark.kl_pd is None or benchmark.kl_pd.empty:
logging.info('{} make benchmark get None'.format(symbol))
return None
if cmp_cnt is not None and benchmark.kl_pd.shape[0] > cmp_cnt:
# 再次根据对比多少个交易日这个参数，对齐时间序列
benchmark.kl_pd = benchmark.kl_pd.iloc[-cmp_cnt:]
# 有了symbol和benchmark，即可开始获取全市场symbol涨跌幅度pd.DataFrame对象all_market_change_df
all_market_change_df = _net_cg_df_create(symbol, benchmark)
return all_market_change_df
def _handle_market_change_df(market_change_df, cmp_cnt, benchmark_df, show_cnt, corr_type, rolling=True, show=True):
"""
使用benchmark_df与全市场market_change_df进行相关系数计算，可视化结果及信息
:param market_change_df: 全市场symbol涨跌幅度pd.DataFrame对象
:param cmp_cnt: 对比多少个交易日，int
:param benchmark_df: 标尺symbol对应的pd.Series对象
:param show_cnt: 最终结果展示以及可视化相似度个数
:param corr_type: ECoreCorrType对象，暂时支持皮尔逊，斯皮尔曼，＋－符号相关系数，移动时间加权相关系数
:param rolling: 是否使用时间加权相关计算，与corr_type = ECoreCorrType.E_CORE_TYPE_ROLLING一样，单独拿出来了
:param show: 是否可视化最终top最相关的股票
:return:
"""
# 使用[-cmp_cnt:]再次确定时间序列周期
benchmark_df = benchmark_df.iloc[-cmp_cnt:]
market_change_df = market_change_df.iloc[-cmp_cnt:]
if corr_type == ECoreCorrType.E_CORE_TYPE_ROLLING:
# 把参数时间加权rolling和corr_type设置进行merge
rolling = True
if rolling:
# 时间加权统一使用ABuCorrcoef.rolling_corr单独计算，即使用两个参数方式计算，详见ABuCorrcoef.rolling_corr
corr_ret = ABuCorrcoef.rolling_corr(market_change_df, benchmark_df)
corr_ret = pd.Series(corr_ret, index=market_change_df.columns, name=benchmark_df.name)
else:
# 其它加权计算统一使用corr_df计算，即统一使用大矩阵计算相关系数后再拿出benchmark_df对应的相关系数列
corr_ret = ABuCorrcoef.corr_matrix(market_change_df, corr_type)[benchmark_df.name]
# 对结果进行zip排序，按照相关系统由正相关到负相关排序
sorted_ret = sorted(zip(corr_ret.index, corr_ret), key=operator.itemgetter(1), reverse=True)
"""
最终sorted_ret为可迭代序列，形如：
[('usTSLA', 1.0), ('usSINA', 0.45565379371028253), ('usWB', 0.44811939073120288),
('usAEH', 0.37792534372729375), ('usCRESY', 0.37347584342214574),
('us.IXIC', 0.36856818073255937), ('usCVG', 0.36841463066151853),
('usOCN', 0.36412381487296047), ('usYHOO', 0.36217456000137549), ...............]
"""
if show:
# 根据是否是ipython环境决定信息输出函数
log_func = logging.info if ABuEnv.g_is_ipython else print
log_func(sorted_ret[:show_cnt])
# 绘制show_cnt个最相关的股票股价走势
ABuSimilarDrawing.draw_show_close(sorted_ret, cmp_cnt, show_cnt)
return sorted_ret
@consume_time
@from_local
def multi_corr_df(corr_jobs, cmp_cnt=252, n_folds=None, start=None, end=None):
"""
被from_local装饰器装饰 即强制走本地数据，匹配市场对应的benchmark，根据参数
使用_all_market_cg获取全市场symbol涨跌幅度pd.DataFrame对象change_df使用
corr_jobs个相关系数计算方法分别计算change_df的相关系数，所有结果组成一个字典返回
:param corr_jobs: 需要执行相关计算方法ECoreCorrType序列
:param cmp_cnt: 对比多少个交易日，int
:param n_folds: 对比n_folds年，int，可选参数
:param start: 请求的开始日期 str对象，可选参数
:param end: 请求的结束日期 str对象，可选参数
:return: 返回相关系数矩阵组成的字典对象，如下所示 eg：
{'pears':
usBIDU usFB usGOOG usNOAH usSFUN usTSLA usVIPS usWUBA
usBIDU 1.0000 0.3013 0.3690 0.4015 0.3680 0.3015 0.3706 0.4320
usFB 0.3013 1.0000 0.6609 0.2746 0.1978 0.4080 0.2856 0.2438
usGOOG 0.3690 0.6609 1.0000 0.3682 0.1821 0.3477 0.3040 0.2917
usNOAH 0.4015 0.2746 0.3682 1.0000 0.3628 0.2178 0.4645 0.4488
usSFUN 0.3680 0.1978 0.1821 0.3628 1.0000 0.2513 0.2843 0.4883
usTSLA 0.3015 0.4080 0.3477 0.2178 0.2513 1.0000 0.2327 0.3340
usVIPS 0.3706 0.2856 0.3040 0.4645 0.2843 0.2327 1.0000 0.4189
usWUBA 0.4320 0.2438 0.2917 0.4488 0.4883 0.3340 0.4189 1.0000
'sperm':
usBIDU usFB usGOOG usNOAH usSFUN usTSLA usVIPS usWUBA
usBIDU 1.0000 0.3888 0.4549 0.4184 0.3747 0.3623 0.4333 0.4396
usFB 0.3888 1.0000 0.7013 0.2927 0.2379 0.4200 0.3123 0.2216
usGOOG 0.4549 0.7013 1.0000 0.3797 0.2413 0.3871 0.3922 0.3035
usNOAH 0.4184 0.2927 0.3797 1.0000 0.3581 0.2066 0.4643 0.4382
usSFUN 0.3747 0.2379 0.2413 0.3581 1.0000 0.2645 0.3890 0.4693
usTSLA 0.3623 0.4200 0.3871 0.2066 0.2645 1.0000 0.2540 0.2801
usVIPS 0.4333 0.3123 0.3922 0.4643 0.3890 0.2540 1.0000 0.4080
usWUBA 0.4396 0.2216 0.3035 0.4382 0.4693 0.2801 0.4080 1.0000 }
"""
if isinstance(corr_jobs, ECoreCorrType):
# 如果直接传递进来一个ECoreCorrType，暂时兼容，做成序列
corr_jobs = [corr_jobs]
if any([not isinstance(corr_job, ECoreCorrType) for corr_job in corr_jobs]):
# 序列中的所有元素必须是ECoreCorrType
raise TypeError('corr_job must ECoreCorrType')
# 匹配市场对应的benchmark
if ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_US:
# 美股
benchmark = IndexSymbol.IXIC
elif ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_HK:
# 港股
benchmark = IndexSymbol.HSI
elif ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_CN:
# a股
benchmark = IndexSymbol.SH
elif ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_FUTURES_CN:
# 国内期货
benchmark = IndexSymbol.BM_FUTURES_CN
elif ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_TC:
# 币类市场
benchmark = IndexSymbol.TC_INX
elif ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_OPTIONS_US:
# 美股期权暂时也以IXIC做为标尺
benchmark = IndexSymbol.IXIC
elif ABuEnv.g_market_target == EMarketTargetType.E_MARKET_TARGET_FUTURES_GLOBAL:
# 国际期货暂时也以BM_FUTURES_GB做为标尺
benchmark = IndexSymbol.BM_FUTURES_GB
else:
# 没匹配上也不抛错误，随便给一个，因为这里要的benchmark主要目的只是做为时间标尺
benchmark = IndexSymbol.IXIC
# 根据参数使用_all_market_cg获取全市场symbol涨跌幅度pd.DataFrame对象change_df
change_df = _all_market_cg(benchmark, cmp_cnt=cmp_cnt, n_folds=n_folds, start=start, end=end)
# 使用corr_jobs个相关系数计算方法分别计算change_df的相关系数，所有结果组成一个字典返回
return {corr_job.value: ABuCorrcoef.corr_matrix(change_df, corr_job) for corr_job in corr_jobs}
| gpl-3.0 |
datapythonista/pandas | pandas/tests/resample/test_datetime_index.py | 1 | 60159 | from datetime import datetime
from functools import partial
from io import StringIO
import numpy as np
import pytest
import pytz
from pandas._libs import lib
from pandas.errors import UnsupportedFunctionCall
import pandas as pd
from pandas import (
DataFrame,
Series,
Timedelta,
Timestamp,
isna,
notna,
)
import pandas._testing as tm
from pandas.core.groupby.grouper import Grouper
from pandas.core.indexes.datetimes import date_range
from pandas.core.indexes.period import (
Period,
period_range,
)
from pandas.core.resample import (
DatetimeIndex,
_get_timestamp_range_edges,
)
import pandas.tseries.offsets as offsets
from pandas.tseries.offsets import Minute
@pytest.fixture()
def _index_factory():
return date_range
@pytest.fixture
def _index_freq():
return "Min"
@pytest.fixture
def _static_values(index):
return np.random.rand(len(index))
def test_custom_grouper(index):
dti = index
s = Series(np.array([1] * len(dti)), index=dti, dtype="int64")
b = Grouper(freq=Minute(5))
g = s.groupby(b)
# check all cython functions work
g.ohlc() # doesn't use _cython_agg_general
funcs = ["add", "mean", "prod", "min", "max", "var"]
for f in funcs:
g._cython_agg_general(f, alt=None, numeric_only=True)
b = Grouper(freq=Minute(5), closed="right", label="right")
g = s.groupby(b)
# check all cython functions work
g.ohlc() # doesn't use _cython_agg_general
funcs = ["add", "mean", "prod", "min", "max", "var"]
for f in funcs:
g._cython_agg_general(f, alt=None, numeric_only=True)
assert g.ngroups == 2593
assert notna(g.mean()).all()
# construct expected val
arr = [1] + [5] * 2592
idx = dti[0:-1:5]
idx = idx.append(dti[-1:])
idx = DatetimeIndex(idx, freq="5T")
expect = Series(arr, index=idx)
# GH2763 - return input dtype if we can
result = g.agg(np.sum)
tm.assert_series_equal(result, expect)
df = DataFrame(np.random.rand(len(dti), 10), index=dti, dtype="float64")
r = df.groupby(b).agg(np.sum)
assert len(r.columns) == 10
assert len(r.index) == 2593
@pytest.mark.parametrize(
"_index_start,_index_end,_index_name",
[("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
)
@pytest.mark.parametrize(
"closed, expected",
[
(
"right",
lambda s: Series(
[s[0], s[1:6].mean(), s[6:11].mean(), s[11:].mean()],
index=date_range("1/1/2000", periods=4, freq="5min", name="index"),
),
),
(
"left",
lambda s: Series(
[s[:5].mean(), s[5:10].mean(), s[10:].mean()],
index=date_range(
"1/1/2000 00:05", periods=3, freq="5min", name="index"
),
),
),
],
)
def test_resample_basic(series, closed, expected):
s = series
expected = expected(s)
result = s.resample("5min", closed=closed, label="right").mean()
tm.assert_series_equal(result, expected)
def test_resample_integerarray():
# GH 25580, resample on IntegerArray
ts = Series(
range(9), index=date_range("1/1/2000", periods=9, freq="T"), dtype="Int64"
)
result = ts.resample("3T").sum()
expected = Series(
[3, 12, 21],
index=date_range("1/1/2000", periods=3, freq="3T"),
dtype="Int64",
)
tm.assert_series_equal(result, expected)
result = ts.resample("3T").mean()
expected = Series(
[1, 4, 7],
index=date_range("1/1/2000", periods=3, freq="3T"),
dtype="Float64",
)
tm.assert_series_equal(result, expected)
def test_resample_basic_grouper(series):
s = series
result = s.resample("5Min").last()
grouper = Grouper(freq=Minute(5), closed="left", label="left")
expected = s.groupby(grouper).agg(lambda x: x[-1])
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"_index_start,_index_end,_index_name",
[("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
)
@pytest.mark.parametrize(
"keyword,value",
[("label", "righttt"), ("closed", "righttt"), ("convention", "starttt")],
)
def test_resample_string_kwargs(series, keyword, value):
# see gh-19303
# Check that wrong keyword argument strings raise an error
msg = f"Unsupported value {value} for `{keyword}`"
with pytest.raises(ValueError, match=msg):
series.resample("5min", **({keyword: value}))
@pytest.mark.parametrize(
"_index_start,_index_end,_index_name",
[("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
)
def test_resample_how(series, downsample_method):
if downsample_method == "ohlc":
pytest.skip("covered by test_resample_how_ohlc")
s = series
grouplist = np.ones_like(s)
grouplist[0] = 0
grouplist[1:6] = 1
grouplist[6:11] = 2
grouplist[11:] = 3
expected = s.groupby(grouplist).agg(downsample_method)
expected.index = date_range("1/1/2000", periods=4, freq="5min", name="index")
result = getattr(
s.resample("5min", closed="right", label="right"), downsample_method
)()
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize(
"_index_start,_index_end,_index_name",
[("1/1/2000 00:00:00", "1/1/2000 00:13:00", "index")],
)
def test_resample_how_ohlc(series):
s = series
grouplist = np.ones_like(s)
grouplist[0] = 0
grouplist[1:6] = 1
grouplist[6:11] = 2
grouplist[11:] = 3
def _ohlc(group):
if isna(group).all():
return np.repeat(np.nan, 4)
return [group[0], group.max(), group.min(), group[-1]]
expected = DataFrame(
s.groupby(grouplist).agg(_ohlc).values.tolist(),
index=date_range("1/1/2000", periods=4, freq="5min", name="index"),
columns=["open", "high", "low", "close"],
)
result = s.resample("5min", closed="right", label="right").ohlc()
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("func", ["min", "max", "sum", "prod", "mean", "var", "std"])
def test_numpy_compat(func):
# see gh-12811
s = Series([1, 2, 3, 4, 5], index=date_range("20130101", periods=5, freq="s"))
r = s.resample("2s")
msg = "numpy operations are not valid with resample"
with pytest.raises(UnsupportedFunctionCall, match=msg):
getattr(r, func)(func, 1, 2, 3)
with pytest.raises(UnsupportedFunctionCall, match=msg):
getattr(r, func)(axis=1)
def test_resample_how_callables():
# GH#7929
data = np.arange(5, dtype=np.int64)
ind = date_range(start="2014-01-01", periods=len(data), freq="d")
df = DataFrame({"A": data, "B": data}, index=ind)
def fn(x, a=1):
return str(type(x))
class FnClass:
def __call__(self, x):
return str(type(x))
df_standard = df.resample("M").apply(fn)
df_lambda = df.resample("M").apply(lambda x: str(type(x)))
df_partial = df.resample("M").apply(partial(fn))
df_partial2 = df.resample("M").apply(partial(fn, a=2))
df_class = df.resample("M").apply(FnClass())
tm.assert_frame_equal(df_standard, df_lambda)
tm.assert_frame_equal(df_standard, df_partial)
tm.assert_frame_equal(df_standard, df_partial2)
tm.assert_frame_equal(df_standard, df_class)
def test_resample_rounding():
# GH 8371
# odd results when rounding is needed
data = """date,time,value
11-08-2014,00:00:01.093,1
11-08-2014,00:00:02.159,1
11-08-2014,00:00:02.667,1
11-08-2014,00:00:03.175,1
11-08-2014,00:00:07.058,1
11-08-2014,00:00:07.362,1
11-08-2014,00:00:08.324,1
11-08-2014,00:00:08.830,1
11-08-2014,00:00:08.982,1
11-08-2014,00:00:09.815,1
11-08-2014,00:00:10.540,1
11-08-2014,00:00:11.061,1
11-08-2014,00:00:11.617,1
11-08-2014,00:00:13.607,1
11-08-2014,00:00:14.535,1
11-08-2014,00:00:15.525,1
11-08-2014,00:00:17.960,1
11-08-2014,00:00:20.674,1
11-08-2014,00:00:21.191,1"""
df = pd.read_csv(
StringIO(data),
parse_dates={"timestamp": ["date", "time"]},
index_col="timestamp",
)
df.index.name = None
result = df.resample("6s").sum()
expected = DataFrame(
{"value": [4, 9, 4, 2]}, index=date_range("2014-11-08", freq="6s", periods=4)
)
tm.assert_frame_equal(result, expected)
result = df.resample("7s").sum()
expected = DataFrame(
{"value": [4, 10, 4, 1]}, index=date_range("2014-11-08", freq="7s", periods=4)
)
tm.assert_frame_equal(result, expected)
result = df.resample("11s").sum()
expected = DataFrame(
{"value": [11, 8]}, index=date_range("2014-11-08", freq="11s", periods=2)
)
tm.assert_frame_equal(result, expected)
result = df.resample("13s").sum()
expected = DataFrame(
{"value": [13, 6]}, index=date_range("2014-11-08", freq="13s", periods=2)
)
tm.assert_frame_equal(result, expected)
result = df.resample("17s").sum()
expected = DataFrame(
{"value": [16, 3]}, index=date_range("2014-11-08", freq="17s", periods=2)
)
tm.assert_frame_equal(result, expected)
def test_resample_basic_from_daily():
# from daily
dti = date_range(
start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq="D", name="index"
)
s = Series(np.random.rand(len(dti)), dti)
# to weekly
result = s.resample("w-sun").last()
assert len(result) == 3
assert (result.index.dayofweek == [6, 6, 6]).all()
assert result.iloc[0] == s["1/2/2005"]
assert result.iloc[1] == s["1/9/2005"]
assert result.iloc[2] == s.iloc[-1]
result = s.resample("W-MON").last()
assert len(result) == 2
assert (result.index.dayofweek == [0, 0]).all()
assert result.iloc[0] == s["1/3/2005"]
assert result.iloc[1] == s["1/10/2005"]
result = s.resample("W-TUE").last()
assert len(result) == 2
assert (result.index.dayofweek == [1, 1]).all()
assert result.iloc[0] == s["1/4/2005"]
assert result.iloc[1] == s["1/10/2005"]
result = s.resample("W-WED").last()
assert len(result) == 2
assert (result.index.dayofweek == [2, 2]).all()
assert result.iloc[0] == s["1/5/2005"]
assert result.iloc[1] == s["1/10/2005"]
result = s.resample("W-THU").last()
assert len(result) == 2
assert (result.index.dayofweek == [3, 3]).all()
assert result.iloc[0] == s["1/6/2005"]
assert result.iloc[1] == s["1/10/2005"]
result = s.resample("W-FRI").last()
assert len(result) == 2
assert (result.index.dayofweek == [4, 4]).all()
assert result.iloc[0] == s["1/7/2005"]
assert result.iloc[1] == s["1/10/2005"]
# to biz day
result = s.resample("B").last()
assert len(result) == 7
assert (result.index.dayofweek == [4, 0, 1, 2, 3, 4, 0]).all()
assert result.iloc[0] == s["1/2/2005"]
assert result.iloc[1] == s["1/3/2005"]
assert result.iloc[5] == s["1/9/2005"]
assert result.index.name == "index"
def test_resample_upsampling_picked_but_not_correct():
# Test for issue #3020
dates = date_range("01-Jan-2014", "05-Jan-2014", freq="D")
series = Series(1, index=dates)
result = series.resample("D").mean()
assert result.index[0] == dates[0]
# GH 5955
# incorrect deciding to upsample when the axis frequency matches the
# resample frequency
s = Series(
np.arange(1.0, 6), index=[datetime(1975, 1, i, 12, 0) for i in range(1, 6)]
)
expected = Series(
np.arange(1.0, 6), index=date_range("19750101", periods=5, freq="D")
)
result = s.resample("D").count()
tm.assert_series_equal(result, Series(1, index=expected.index))
result1 = s.resample("D").sum()
result2 = s.resample("D").mean()
tm.assert_series_equal(result1, expected)
tm.assert_series_equal(result2, expected)
def test_resample_frame_basic():
df = tm.makeTimeDataFrame()
b = Grouper(freq="M")
g = df.groupby(b)
# check all cython functions work
funcs = ["add", "mean", "prod", "min", "max", "var"]
for f in funcs:
g._cython_agg_general(f, alt=None, numeric_only=True)
result = df.resample("A").mean()
tm.assert_series_equal(result["A"], df["A"].resample("A").mean())
result = df.resample("M").mean()
tm.assert_series_equal(result["A"], df["A"].resample("M").mean())
df.resample("M", kind="period").mean()
df.resample("W-WED", kind="period").mean()
def test_resample_upsample():
# from daily
dti = date_range(
start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq="D", name="index"
)
s = Series(np.random.rand(len(dti)), dti)
# to minutely, by padding
result = s.resample("Min").pad()
assert len(result) == 12961
assert result[0] == s[0]
assert result[-1] == s[-1]
assert result.index.name == "index"
def test_resample_how_method():
# GH9915
s = Series(
[11, 22],
index=[
Timestamp("2015-03-31 21:48:52.672000"),
Timestamp("2015-03-31 21:49:52.739000"),
],
)
expected = Series(
[11, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, 22],
index=DatetimeIndex(
[
Timestamp("2015-03-31 21:48:50"),
Timestamp("2015-03-31 21:49:00"),
Timestamp("2015-03-31 21:49:10"),
Timestamp("2015-03-31 21:49:20"),
Timestamp("2015-03-31 21:49:30"),
Timestamp("2015-03-31 21:49:40"),
Timestamp("2015-03-31 21:49:50"),
],
freq="10s",
),
)
tm.assert_series_equal(s.resample("10S").mean(), expected)
def test_resample_extra_index_point():
# GH#9756
index = date_range(start="20150101", end="20150331", freq="BM")
expected = DataFrame({"A": Series([21, 41, 63], index=index)})
index = date_range(start="20150101", end="20150331", freq="B")
df = DataFrame({"A": Series(range(len(index)), index=index)}, dtype="int64")
result = df.resample("BM").last()
tm.assert_frame_equal(result, expected)
def test_upsample_with_limit():
rng = date_range("1/1/2000", periods=3, freq="5t")
ts = Series(np.random.randn(len(rng)), rng)
result = ts.resample("t").ffill(limit=2)
expected = ts.reindex(result.index, method="ffill", limit=2)
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize("freq", ["5D", "10H", "5Min", "10S"])
@pytest.mark.parametrize("rule", ["Y", "3M", "15D", "30H", "15Min", "30S"])
def test_nearest_upsample_with_limit(tz_aware_fixture, freq, rule):
# GH 33939
rng = date_range("1/1/2000", periods=3, freq=freq, tz=tz_aware_fixture)
ts = Series(np.random.randn(len(rng)), rng)
result = ts.resample(rule).nearest(limit=2)
expected = ts.reindex(result.index, method="nearest", limit=2)
tm.assert_series_equal(result, expected)
def test_resample_ohlc(series):
s = series
grouper = Grouper(freq=Minute(5))
expect = s.groupby(grouper).agg(lambda x: x[-1])
result = s.resample("5Min").ohlc()
assert len(result) == len(expect)
assert len(result.columns) == 4
xs = result.iloc[-2]
assert xs["open"] == s[-6]
assert xs["high"] == s[-6:-1].max()
assert xs["low"] == s[-6:-1].min()
assert xs["close"] == s[-2]
xs = result.iloc[0]
assert xs["open"] == s[0]
assert xs["high"] == s[:5].max()
assert xs["low"] == s[:5].min()
assert xs["close"] == s[4]
def test_resample_ohlc_result():
# GH 12332
index = date_range("1-1-2000", "2-15-2000", freq="h")
index = index.union(date_range("4-15-2000", "5-15-2000", freq="h"))
s = Series(range(len(index)), index=index)
a = s.loc[:"4-15-2000"].resample("30T").ohlc()
assert isinstance(a, DataFrame)
b = s.loc[:"4-14-2000"].resample("30T").ohlc()
assert isinstance(b, DataFrame)
# GH12348
# raising on odd period
rng = date_range("2013-12-30", "2014-01-07")
index = rng.drop(
[
Timestamp("2014-01-01"),
Timestamp("2013-12-31"),
Timestamp("2014-01-04"),
Timestamp("2014-01-05"),
]
)
df = DataFrame(data=np.arange(len(index)), index=index)
result = df.resample("B").mean()
expected = df.reindex(index=date_range(rng[0], rng[-1], freq="B"))
tm.assert_frame_equal(result, expected)
def test_resample_ohlc_dataframe():
df = (
DataFrame(
{
"PRICE": {
Timestamp("2011-01-06 10:59:05", tz=None): 24990,
Timestamp("2011-01-06 12:43:33", tz=None): 25499,
Timestamp("2011-01-06 12:54:09", tz=None): 25499,
},
"VOLUME": {
Timestamp("2011-01-06 10:59:05", tz=None): 1500000000,
Timestamp("2011-01-06 12:43:33", tz=None): 5000000000,
Timestamp("2011-01-06 12:54:09", tz=None): 100000000,
},
}
)
).reindex(["VOLUME", "PRICE"], axis=1)
res = df.resample("H").ohlc()
exp = pd.concat(
[df["VOLUME"].resample("H").ohlc(), df["PRICE"].resample("H").ohlc()],
axis=1,
keys=["VOLUME", "PRICE"],
)
tm.assert_frame_equal(exp, res)
df.columns = [["a", "b"], ["c", "d"]]
res = df.resample("H").ohlc()
exp.columns = pd.MultiIndex.from_tuples(
[
("a", "c", "open"),
("a", "c", "high"),
("a", "c", "low"),
("a", "c", "close"),
("b", "d", "open"),
("b", "d", "high"),
("b", "d", "low"),
("b", "d", "close"),
]
)
tm.assert_frame_equal(exp, res)
# dupe columns fail atm
# df.columns = ['PRICE', 'PRICE']
def test_resample_dup_index():
# GH 4812
# dup columns with resample raising
df = DataFrame(
np.random.randn(4, 12),
index=[2000, 2000, 2000, 2000],
columns=[Period(year=2000, month=i + 1, freq="M") for i in range(12)],
)
df.iloc[3, :] = np.nan
result = df.resample("Q", axis=1).mean()
expected = df.groupby(lambda x: int((x.month - 1) / 3), axis=1).mean()
expected.columns = [Period(year=2000, quarter=i + 1, freq="Q") for i in range(4)]
tm.assert_frame_equal(result, expected)
def test_resample_reresample():
dti = date_range(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq="D")
s = Series(np.random.rand(len(dti)), dti)
bs = s.resample("B", closed="right", label="right").mean()
result = bs.resample("8H").mean()
assert len(result) == 22
assert isinstance(result.index.freq, offsets.DateOffset)
assert result.index.freq == offsets.Hour(8)
def test_resample_timestamp_to_period(simple_date_range_series):
ts = simple_date_range_series("1/1/1990", "1/1/2000")
result = ts.resample("A-DEC", kind="period").mean()
expected = ts.resample("A-DEC").mean()
expected.index = period_range("1990", "2000", freq="a-dec")
tm.assert_series_equal(result, expected)
result = ts.resample("A-JUN", kind="period").mean()
expected = ts.resample("A-JUN").mean()
expected.index = period_range("1990", "2000", freq="a-jun")
tm.assert_series_equal(result, expected)
result = ts.resample("M", kind="period").mean()
expected = ts.resample("M").mean()
expected.index = period_range("1990-01", "2000-01", freq="M")
tm.assert_series_equal(result, expected)
result = ts.resample("M", kind="period").mean()
expected = ts.resample("M").mean()
expected.index = period_range("1990-01", "2000-01", freq="M")
tm.assert_series_equal(result, expected)
def test_ohlc_5min():
def _ohlc(group):
if isna(group).all():
return np.repeat(np.nan, 4)
return [group[0], group.max(), group.min(), group[-1]]
rng = date_range("1/1/2000 00:00:00", "1/1/2000 5:59:50", freq="10s")
ts = Series(np.random.randn(len(rng)), index=rng)
resampled = ts.resample("5min", closed="right", label="right").ohlc()
assert (resampled.loc["1/1/2000 00:00"] == ts[0]).all()
exp = _ohlc(ts[1:31])
assert (resampled.loc["1/1/2000 00:05"] == exp).all()
exp = _ohlc(ts["1/1/2000 5:55:01":])
assert (resampled.loc["1/1/2000 6:00:00"] == exp).all()
def test_downsample_non_unique():
rng = date_range("1/1/2000", "2/29/2000")
rng2 = rng.repeat(5).values
ts = Series(np.random.randn(len(rng2)), index=rng2)
result = ts.resample("M").mean()
expected = ts.groupby(lambda x: x.month).mean()
assert len(result) == 2
tm.assert_almost_equal(result[0], expected[1])
tm.assert_almost_equal(result[1], expected[2])
def test_asfreq_non_unique():
# GH #1077
rng = date_range("1/1/2000", "2/29/2000")
rng2 = rng.repeat(2).values
ts = Series(np.random.randn(len(rng2)), index=rng2)
msg = "cannot reindex from a duplicate axis"
with pytest.raises(ValueError, match=msg):
ts.asfreq("B")
def test_resample_axis1():
rng = date_range("1/1/2000", "2/29/2000")
df = DataFrame(np.random.randn(3, len(rng)), columns=rng, index=["a", "b", "c"])
result = df.resample("M", axis=1).mean()
expected = df.T.resample("M").mean().T
tm.assert_frame_equal(result, expected)
def test_resample_anchored_ticks():
# If a fixed delta (5 minute, 4 hour) evenly divides a day, we should
# "anchor" the origin at midnight so we get regular intervals rather
# than starting from the first timestamp which might start in the
# middle of a desired interval
rng = date_range("1/1/2000 04:00:00", periods=86400, freq="s")
ts = Series(np.random.randn(len(rng)), index=rng)
ts[:2] = np.nan # so results are the same
freqs = ["t", "5t", "15t", "30t", "4h", "12h"]
for freq in freqs:
result = ts[2:].resample(freq, closed="left", label="left").mean()
expected = ts.resample(freq, closed="left", label="left").mean()
tm.assert_series_equal(result, expected)
def test_resample_single_group():
mysum = lambda x: x.sum()
rng = date_range("2000-1-1", "2000-2-10", freq="D")
ts = Series(np.random.randn(len(rng)), index=rng)
tm.assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
rng = date_range("2000-1-1", "2000-1-10", freq="D")
ts = Series(np.random.randn(len(rng)), index=rng)
tm.assert_series_equal(ts.resample("M").sum(), ts.resample("M").apply(mysum))
# GH 3849
s = Series(
[30.1, 31.6],
index=[Timestamp("20070915 15:30:00"), Timestamp("20070915 15:40:00")],
)
expected = Series([0.75], index=DatetimeIndex([Timestamp("20070915")], freq="D"))
result = s.resample("D").apply(lambda x: np.std(x))
tm.assert_series_equal(result, expected)
def test_resample_offset():
# GH 31809
rng = date_range("1/1/2000 00:00:00", "1/1/2000 02:00", freq="s")
ts = Series(np.random.randn(len(rng)), index=rng)
resampled = ts.resample("5min", offset="2min").mean()
exp_rng = date_range("12/31/1999 23:57:00", "1/1/2000 01:57", freq="5min")
tm.assert_index_equal(resampled.index, exp_rng)
def test_resample_origin():
# GH 31809
rng = date_range("2000-01-01 00:00:00", "2000-01-01 02:00", freq="s")
ts = Series(np.random.randn(len(rng)), index=rng)
exp_rng = date_range("1999-12-31 23:57:00", "2000-01-01 01:57", freq="5min")
resampled = ts.resample("5min", origin="1999-12-31 23:57:00").mean()
tm.assert_index_equal(resampled.index, exp_rng)
offset_timestamp = Timestamp(0) + Timedelta("2min")
resampled = ts.resample("5min", origin=offset_timestamp).mean()
tm.assert_index_equal(resampled.index, exp_rng)
resampled = ts.resample("5min", origin="epoch", offset="2m").mean()
tm.assert_index_equal(resampled.index, exp_rng)
# origin of '1999-31-12 12:02:00' should be equivalent for this case
resampled = ts.resample("5min", origin="1999-12-31 12:02:00").mean()
tm.assert_index_equal(resampled.index, exp_rng)
resampled = ts.resample("5min", offset="-3m").mean()
tm.assert_index_equal(resampled.index, exp_rng)
@pytest.mark.parametrize(
"origin", ["invalid_value", "epch", "startday", "startt", "2000-30-30", object()]
)
def test_resample_bad_origin(origin):
rng = date_range("2000-01-01 00:00:00", "2000-01-01 02:00", freq="s")
ts = Series(np.random.randn(len(rng)), index=rng)
msg = (
"'origin' should be equal to 'epoch', 'start', 'start_day', "
"'end', 'end_day' or should be a Timestamp convertible type. Got "
f"'{origin}' instead."
)
with pytest.raises(ValueError, match=msg):
ts.resample("5min", origin=origin)
@pytest.mark.parametrize("offset", ["invalid_value", "12dayys", "2000-30-30", object()])
def test_resample_bad_offset(offset):
rng = date_range("2000-01-01 00:00:00", "2000-01-01 02:00", freq="s")
ts = Series(np.random.randn(len(rng)), index=rng)
msg = f"'offset' should be a Timedelta convertible type. Got '{offset}' instead."
with pytest.raises(ValueError, match=msg):
ts.resample("5min", offset=offset)
def test_resample_origin_prime_freq():
# GH 31809
start, end = "2000-10-01 23:30:00", "2000-10-02 00:30:00"
rng = date_range(start, end, freq="7min")
ts = Series(np.random.randn(len(rng)), index=rng)
exp_rng = date_range("2000-10-01 23:14:00", "2000-10-02 00:22:00", freq="17min")
resampled = ts.resample("17min").mean()
tm.assert_index_equal(resampled.index, exp_rng)
resampled = ts.resample("17min", origin="start_day").mean()
tm.assert_index_equal(resampled.index, exp_rng)
exp_rng = date_range("2000-10-01 23:30:00", "2000-10-02 00:21:00", freq="17min")
resampled = ts.resample("17min", origin="start").mean()
tm.assert_index_equal(resampled.index, exp_rng)
resampled = ts.resample("17min", offset="23h30min").mean()
tm.assert_index_equal(resampled.index, exp_rng)
resampled = ts.resample("17min", origin="start_day", offset="23h30min").mean()
tm.assert_index_equal(resampled.index, exp_rng)
exp_rng = date_range("2000-10-01 23:18:00", "2000-10-02 00:26:00", freq="17min")
resampled = ts.resample("17min", origin="epoch").mean()
tm.assert_index_equal(resampled.index, exp_rng)
exp_rng = date_range("2000-10-01 23:24:00", "2000-10-02 00:15:00", freq="17min")
resampled = ts.resample("17min", origin="2000-01-01").mean()
tm.assert_index_equal(resampled.index, exp_rng)
def test_resample_origin_with_tz():
# GH 31809
msg = "The origin must have the same timezone as the index."
tz = "Europe/Paris"
rng = date_range("2000-01-01 00:00:00", "2000-01-01 02:00", freq="s", tz=tz)
ts = Series(np.random.randn(len(rng)), index=rng)
exp_rng = date_range("1999-12-31 23:57:00", "2000-01-01 01:57", freq="5min", tz=tz)
resampled = ts.resample("5min", origin="1999-12-31 23:57:00+00:00").mean()
tm.assert_index_equal(resampled.index, exp_rng)
# origin of '1999-31-12 12:02:00+03:00' should be equivalent for this case
resampled = ts.resample("5min", origin="1999-12-31 12:02:00+03:00").mean()
tm.assert_index_equal(resampled.index, exp_rng)
resampled = ts.resample("5min", origin="epoch", offset="2m").mean()
tm.assert_index_equal(resampled.index, exp_rng)
with pytest.raises(ValueError, match=msg):
ts.resample("5min", origin="12/31/1999 23:57:00").mean()
# if the series is not tz aware, origin should not be tz aware
rng = date_range("2000-01-01 00:00:00", "2000-01-01 02:00", freq="s")
ts = Series(np.random.randn(len(rng)), index=rng)
with pytest.raises(ValueError, match=msg):
ts.resample("5min", origin="12/31/1999 23:57:00+03:00").mean()
def test_resample_origin_epoch_with_tz_day_vs_24h():
# GH 34474
start, end = "2000-10-01 23:30:00+0500", "2000-12-02 00:30:00+0500"
rng = date_range(start, end, freq="7min")
random_values = np.random.randn(len(rng))
ts_1 = Series(random_values, index=rng)
result_1 = ts_1.resample("D", origin="epoch").mean()
result_2 = ts_1.resample("24H", origin="epoch").mean()
tm.assert_series_equal(result_1, result_2)
# check that we have the same behavior with epoch even if we are not timezone aware
ts_no_tz = ts_1.tz_localize(None)
result_3 = ts_no_tz.resample("D", origin="epoch").mean()
result_4 = ts_no_tz.resample("24H", origin="epoch").mean()
tm.assert_series_equal(result_1, result_3.tz_localize(rng.tz), check_freq=False)
tm.assert_series_equal(result_1, result_4.tz_localize(rng.tz), check_freq=False)
# check that we have the similar results with two different timezones (+2H and +5H)
start, end = "2000-10-01 23:30:00+0200", "2000-12-02 00:30:00+0200"
rng = date_range(start, end, freq="7min")
ts_2 = Series(random_values, index=rng)
result_5 = ts_2.resample("D", origin="epoch").mean()
result_6 = ts_2.resample("24H", origin="epoch").mean()
tm.assert_series_equal(result_1.tz_localize(None), result_5.tz_localize(None))
tm.assert_series_equal(result_1.tz_localize(None), result_6.tz_localize(None))
def test_resample_origin_with_day_freq_on_dst():
# GH 31809
tz = "America/Chicago"
def _create_series(values, timestamps, freq="D"):
return Series(
values,
index=DatetimeIndex(
[Timestamp(t, tz=tz) for t in timestamps], freq=freq, ambiguous=True
),
)
# test classical behavior of origin in a DST context
start = Timestamp("2013-11-02", tz=tz)
end = Timestamp("2013-11-03 23:59", tz=tz)
rng = date_range(start, end, freq="1h")
ts = Series(np.ones(len(rng)), index=rng)
expected = _create_series([24.0, 25.0], ["2013-11-02", "2013-11-03"])
for origin in ["epoch", "start", "start_day", start, None]:
result = ts.resample("D", origin=origin).sum()
tm.assert_series_equal(result, expected)
# test complex behavior of origin/offset in a DST context
start = Timestamp("2013-11-03", tz=tz)
end = Timestamp("2013-11-03 23:59", tz=tz)
rng = date_range(start, end, freq="1h")
ts = Series(np.ones(len(rng)), index=rng)
expected_ts = ["2013-11-02 22:00-05:00", "2013-11-03 22:00-06:00"]
expected = _create_series([23.0, 2.0], expected_ts)
result = ts.resample("D", origin="start", offset="-2H").sum()
tm.assert_series_equal(result, expected)
expected_ts = ["2013-11-02 22:00-05:00", "2013-11-03 21:00-06:00"]
expected = _create_series([22.0, 3.0], expected_ts, freq="24H")
result = ts.resample("24H", origin="start", offset="-2H").sum()
tm.assert_series_equal(result, expected)
expected_ts = ["2013-11-02 02:00-05:00", "2013-11-03 02:00-06:00"]
expected = _create_series([3.0, 22.0], expected_ts)
result = ts.resample("D", origin="start", offset="2H").sum()
tm.assert_series_equal(result, expected)
expected_ts = ["2013-11-02 23:00-05:00", "2013-11-03 23:00-06:00"]
expected = _create_series([24.0, 1.0], expected_ts)
result = ts.resample("D", origin="start", offset="-1H").sum()
tm.assert_series_equal(result, expected)
expected_ts = ["2013-11-02 01:00-05:00", "2013-11-03 01:00:00-0500"]
expected = _create_series([1.0, 24.0], expected_ts)
result = ts.resample("D", origin="start", offset="1H").sum()
tm.assert_series_equal(result, expected)
def test_resample_daily_anchored():
rng = date_range("1/1/2000 0:00:00", periods=10000, freq="T")
ts = Series(np.random.randn(len(rng)), index=rng)
ts[:2] = np.nan # so results are the same
result = ts[2:].resample("D", closed="left", label="left").mean()
expected = ts.resample("D", closed="left", label="left").mean()
tm.assert_series_equal(result, expected)
def test_resample_to_period_monthly_buglet():
# GH #1259
rng = date_range("1/1/2000", "12/31/2000")
ts = Series(np.random.randn(len(rng)), index=rng)
result = ts.resample("M", kind="period").mean()
exp_index = period_range("Jan-2000", "Dec-2000", freq="M")
tm.assert_index_equal(result.index, exp_index)
def test_period_with_agg():
# aggregate a period resampler with a lambda
s2 = Series(
np.random.randint(0, 5, 50),
index=period_range("2012-01-01", freq="H", periods=50),
dtype="float64",
)
expected = s2.to_timestamp().resample("D").mean().to_period()
result = s2.resample("D").agg(lambda x: x.mean())
tm.assert_series_equal(result, expected)
def test_resample_segfault():
# GH 8573
# segfaulting in older versions
all_wins_and_wagers = [
(1, datetime(2013, 10, 1, 16, 20), 1, 0),
(2, datetime(2013, 10, 1, 16, 10), 1, 0),
(2, datetime(2013, 10, 1, 18, 15), 1, 0),
(2, datetime(2013, 10, 1, 16, 10, 31), 1, 0),
]
df = DataFrame.from_records(
all_wins_and_wagers, columns=("ID", "timestamp", "A", "B")
).set_index("timestamp")
result = df.groupby("ID").resample("5min").sum()
expected = df.groupby("ID").apply(lambda x: x.resample("5min").sum())
tm.assert_frame_equal(result, expected)
def test_resample_dtype_preservation():
# GH 12202
# validation tests for dtype preservation
df = DataFrame(
{
"date": date_range(start="2016-01-01", periods=4, freq="W"),
"group": [1, 1, 2, 2],
"val": Series([5, 6, 7, 8], dtype="int32"),
}
).set_index("date")
result = df.resample("1D").ffill()
assert result.val.dtype == np.int32
result = df.groupby("group").resample("1D").ffill()
assert result.val.dtype == np.int32
def test_resample_dtype_coercion():
pytest.importorskip("scipy.interpolate")
# GH 16361
df = {"a": [1, 3, 1, 4]}
df = DataFrame(df, index=date_range("2017-01-01", "2017-01-04"))
expected = df.astype("float64").resample("H").mean()["a"].interpolate("cubic")
result = df.resample("H")["a"].mean().interpolate("cubic")
tm.assert_series_equal(result, expected)
result = df.resample("H").mean()["a"].interpolate("cubic")
tm.assert_series_equal(result, expected)
def test_weekly_resample_buglet():
# #1327
rng = date_range("1/1/2000", freq="B", periods=20)
ts = Series(np.random.randn(len(rng)), index=rng)
resampled = ts.resample("W").mean()
expected = ts.resample("W-SUN").mean()
tm.assert_series_equal(resampled, expected)
def test_monthly_resample_error():
# #1451
dates = date_range("4/16/2012 20:00", periods=5000, freq="h")
ts = Series(np.random.randn(len(dates)), index=dates)
# it works!
ts.resample("M")
def test_nanosecond_resample_error():
# GH 12307 - Values falls after last bin when
# Resampling using pd.tseries.offsets.Nano as period
start = 1443707890427
exp_start = 1443707890400
indx = date_range(start=pd.to_datetime(start), periods=10, freq="100n")
ts = Series(range(len(indx)), index=indx)
r = ts.resample(pd.tseries.offsets.Nano(100))
result = r.agg("mean")
exp_indx = date_range(start=pd.to_datetime(exp_start), periods=10, freq="100n")
exp = Series(range(len(exp_indx)), index=exp_indx, dtype=float)
tm.assert_series_equal(result, exp)
def test_resample_anchored_intraday(simple_date_range_series):
# #1471, #1458
rng = date_range("1/1/2012", "4/1/2012", freq="100min")
df = DataFrame(rng.month, index=rng)
result = df.resample("M").mean()
expected = df.resample("M", kind="period").mean().to_timestamp(how="end")
expected.index += Timedelta(1, "ns") - Timedelta(1, "D")
expected.index = expected.index._with_freq("infer")
assert expected.index.freq == "M"
tm.assert_frame_equal(result, expected)
result = df.resample("M", closed="left").mean()
exp = df.shift(1, freq="D").resample("M", kind="period").mean()
exp = exp.to_timestamp(how="end")
exp.index = exp.index + Timedelta(1, "ns") - Timedelta(1, "D")
exp.index = exp.index._with_freq("infer")
assert exp.index.freq == "M"
tm.assert_frame_equal(result, exp)
rng = date_range("1/1/2012", "4/1/2012", freq="100min")
df = DataFrame(rng.month, index=rng)
result = df.resample("Q").mean()
expected = df.resample("Q", kind="period").mean().to_timestamp(how="end")
expected.index += Timedelta(1, "ns") - Timedelta(1, "D")
expected.index._data.freq = "Q"
expected.index._freq = lib.no_default
tm.assert_frame_equal(result, expected)
result = df.resample("Q", closed="left").mean()
expected = df.shift(1, freq="D").resample("Q", kind="period", closed="left").mean()
expected = expected.to_timestamp(how="end")
expected.index += Timedelta(1, "ns") - Timedelta(1, "D")
expected.index._data.freq = "Q"
expected.index._freq = lib.no_default
tm.assert_frame_equal(result, expected)
ts = simple_date_range_series("2012-04-29 23:00", "2012-04-30 5:00", freq="h")
resampled = ts.resample("M").mean()
assert len(resampled) == 1
def test_resample_anchored_monthstart(simple_date_range_series):
ts = simple_date_range_series("1/1/2000", "12/31/2002")
freqs = ["MS", "BMS", "QS-MAR", "AS-DEC", "AS-JUN"]
for freq in freqs:
ts.resample(freq).mean()
def test_resample_anchored_multiday():
# When resampling a range spanning multiple days, ensure that the
# start date gets used to determine the offset. Fixes issue where
# a one day period is not a multiple of the frequency.
#
# See: https://github.com/pandas-dev/pandas/issues/8683
index1 = date_range("2014-10-14 23:06:23.206", periods=3, freq="400L")
index2 = date_range("2014-10-15 23:00:00", periods=2, freq="2200L")
index = index1.union(index2)
s = Series(np.random.randn(5), index=index)
# Ensure left closing works
result = s.resample("2200L").mean()
assert result.index[-1] == Timestamp("2014-10-15 23:00:02.000")
# Ensure right closing works
result = s.resample("2200L", label="right").mean()
assert result.index[-1] == Timestamp("2014-10-15 23:00:04.200")
def test_corner_cases(simple_period_range_series, simple_date_range_series):
# miscellaneous test coverage
rng = date_range("1/1/2000", periods=12, freq="t")
ts = Series(np.random.randn(len(rng)), index=rng)
result = ts.resample("5t", closed="right", label="left").mean()
ex_index = date_range("1999-12-31 23:55", periods=4, freq="5t")
tm.assert_index_equal(result.index, ex_index)
len0pts = simple_period_range_series("2007-01", "2010-05", freq="M")[:0]
# it works
result = len0pts.resample("A-DEC").mean()
assert len(result) == 0
# resample to periods
ts = simple_date_range_series("2000-04-28", "2000-04-30 11:00", freq="h")
result = ts.resample("M", kind="period").mean()
assert len(result) == 1
assert result.index[0] == Period("2000-04", freq="M")
def test_anchored_lowercase_buglet():
dates = date_range("4/16/2012 20:00", periods=50000, freq="s")
ts = Series(np.random.randn(len(dates)), index=dates)
# it works!
ts.resample("d").mean()
def test_upsample_apply_functions():
# #1596
rng = date_range("2012-06-12", periods=4, freq="h")
ts = Series(np.random.randn(len(rng)), index=rng)
result = ts.resample("20min").aggregate(["mean", "sum"])
assert isinstance(result, DataFrame)
def test_resample_not_monotonic():
rng = date_range("2012-06-12", periods=200, freq="h")
ts = Series(np.random.randn(len(rng)), index=rng)
ts = ts.take(np.random.permutation(len(ts)))
result = ts.resample("D").sum()
exp = ts.sort_index().resample("D").sum()
tm.assert_series_equal(result, exp)
def test_resample_median_bug_1688():
for dtype in ["int64", "int32", "float64", "float32"]:
df = DataFrame(
[1, 2],
index=[datetime(2012, 1, 1, 0, 0, 0), datetime(2012, 1, 1, 0, 5, 0)],
dtype=dtype,
)
result = df.resample("T").apply(lambda x: x.mean())
exp = df.asfreq("T")
if dtype == "float32":
# TODO: Empty groups cause x.mean() to return float64
exp = exp.astype("float64")
tm.assert_frame_equal(result, exp)
result = df.resample("T").median()
exp = df.asfreq("T")
tm.assert_frame_equal(result, exp)
def test_how_lambda_functions(simple_date_range_series):
ts = simple_date_range_series("1/1/2000", "4/1/2000")
result = ts.resample("M").apply(lambda x: x.mean())
exp = ts.resample("M").mean()
tm.assert_series_equal(result, exp)
foo_exp = ts.resample("M").mean()
foo_exp.name = "foo"
bar_exp = ts.resample("M").std()
bar_exp.name = "bar"
result = ts.resample("M").apply([lambda x: x.mean(), lambda x: x.std(ddof=1)])
result.columns = ["foo", "bar"]
tm.assert_series_equal(result["foo"], foo_exp)
tm.assert_series_equal(result["bar"], bar_exp)
# this is a MI Series, so comparing the names of the results
# doesn't make sense
result = ts.resample("M").aggregate(
{"foo": lambda x: x.mean(), "bar": lambda x: x.std(ddof=1)}
)
tm.assert_series_equal(result["foo"], foo_exp, check_names=False)
tm.assert_series_equal(result["bar"], bar_exp, check_names=False)
def test_resample_unequal_times():
# #1772
start = datetime(1999, 3, 1, 5)
# end hour is less than start
end = datetime(2012, 7, 31, 4)
bad_ind = date_range(start, end, freq="30min")
df = DataFrame({"close": 1}, index=bad_ind)
# it works!
df.resample("AS").sum()
def test_resample_consistency():
# GH 6418
# resample with bfill / limit / reindex consistency
i30 = date_range("2002-02-02", periods=4, freq="30T")
s = Series(np.arange(4.0), index=i30)
s[2] = np.NaN
# Upsample by factor 3 with reindex() and resample() methods:
i10 = date_range(i30[0], i30[-1], freq="10T")
s10 = s.reindex(index=i10, method="bfill")
s10_2 = s.reindex(index=i10, method="bfill", limit=2)
rl = s.reindex_like(s10, method="bfill", limit=2)
r10_2 = s.resample("10Min").bfill(limit=2)
r10 = s.resample("10Min").bfill()
# s10_2, r10, r10_2, rl should all be equal
tm.assert_series_equal(s10_2, r10)
tm.assert_series_equal(s10_2, r10_2)
tm.assert_series_equal(s10_2, rl)
def test_resample_timegrouper():
# GH 7227
dates1 = [
datetime(2014, 10, 1),
datetime(2014, 9, 3),
datetime(2014, 11, 5),
datetime(2014, 9, 5),
datetime(2014, 10, 8),
datetime(2014, 7, 15),
]
dates2 = dates1[:2] + [pd.NaT] + dates1[2:4] + [pd.NaT] + dates1[4:]
dates3 = [pd.NaT] + dates1 + [pd.NaT]
for dates in [dates1, dates2, dates3]:
df = DataFrame({"A": dates, "B": np.arange(len(dates))})
result = df.set_index("A").resample("M").count()
exp_idx = DatetimeIndex(
["2014-07-31", "2014-08-31", "2014-09-30", "2014-10-31", "2014-11-30"],
freq="M",
name="A",
)
expected = DataFrame({"B": [1, 0, 2, 2, 1]}, index=exp_idx)
if df["A"].isna().any():
expected.index = expected.index._with_freq(None)
tm.assert_frame_equal(result, expected)
result = df.groupby(Grouper(freq="M", key="A")).count()
tm.assert_frame_equal(result, expected)
df = DataFrame(
{"A": dates, "B": np.arange(len(dates)), "C": np.arange(len(dates))}
)
result = df.set_index("A").resample("M").count()
expected = DataFrame(
{"B": [1, 0, 2, 2, 1], "C": [1, 0, 2, 2, 1]},
index=exp_idx,
columns=["B", "C"],
)
if df["A"].isna().any():
expected.index = expected.index._with_freq(None)
tm.assert_frame_equal(result, expected)
result = df.groupby(Grouper(freq="M", key="A")).count()
tm.assert_frame_equal(result, expected)
def test_resample_nunique():
# GH 12352
df = DataFrame(
{
"ID": {
Timestamp("2015-06-05 00:00:00"): "0010100903",
Timestamp("2015-06-08 00:00:00"): "0010150847",
},
"DATE": {
Timestamp("2015-06-05 00:00:00"): "2015-06-05",
Timestamp("2015-06-08 00:00:00"): "2015-06-08",
},
}
)
r = df.resample("D")
g = df.groupby(Grouper(freq="D"))
expected = df.groupby(Grouper(freq="D")).ID.apply(lambda x: x.nunique())
assert expected.name == "ID"
for t in [r, g]:
result = t.ID.nunique()
tm.assert_series_equal(result, expected)
result = df.ID.resample("D").nunique()
tm.assert_series_equal(result, expected)
result = df.ID.groupby(Grouper(freq="D")).nunique()
tm.assert_series_equal(result, expected)
def test_resample_nunique_preserves_column_level_names():
# see gh-23222
df = tm.makeTimeDataFrame(freq="1D").abs()
df.columns = pd.MultiIndex.from_arrays(
[df.columns.tolist()] * 2, names=["lev0", "lev1"]
)
result = df.resample("1h").nunique()
tm.assert_index_equal(df.columns, result.columns)
def test_resample_nunique_with_date_gap():
# GH 13453
index = date_range("1-1-2000", "2-15-2000", freq="h")
index2 = date_range("4-15-2000", "5-15-2000", freq="h")
index3 = index.append(index2)
s = Series(range(len(index3)), index=index3, dtype="int64")
r = s.resample("M")
# Since all elements are unique, these should all be the same
results = [r.count(), r.nunique(), r.agg(Series.nunique), r.agg("nunique")]
tm.assert_series_equal(results[0], results[1])
tm.assert_series_equal(results[0], results[2])
tm.assert_series_equal(results[0], results[3])
@pytest.mark.parametrize("n", [10000, 100000])
@pytest.mark.parametrize("k", [10, 100, 1000])
def test_resample_group_info(n, k):
# GH10914
# use a fixed seed to always have the same uniques
prng = np.random.RandomState(1234)
dr = date_range(start="2015-08-27", periods=n // 10, freq="T")
ts = Series(prng.randint(0, n // k, n).astype("int64"), index=prng.choice(dr, n))
left = ts.resample("30T").nunique()
ix = date_range(start=ts.index.min(), end=ts.index.max(), freq="30T")
vals = ts.values
bins = np.searchsorted(ix.values, ts.index, side="right")
sorter = np.lexsort((vals, bins))
vals, bins = vals[sorter], bins[sorter]
mask = np.r_[True, vals[1:] != vals[:-1]]
mask |= np.r_[True, bins[1:] != bins[:-1]]
arr = np.bincount(bins[mask] - 1, minlength=len(ix)).astype("int64", copy=False)
right = Series(arr, index=ix)
tm.assert_series_equal(left, right)
def test_resample_size():
n = 10000
dr = date_range("2015-09-19", periods=n, freq="T")
ts = Series(np.random.randn(n), index=np.random.choice(dr, n))
left = ts.resample("7T").size()
ix = date_range(start=left.index.min(), end=ts.index.max(), freq="7T")
bins = np.searchsorted(ix.values, ts.index.values, side="right")
val = np.bincount(bins, minlength=len(ix) + 1)[1:].astype("int64", copy=False)
right = Series(val, index=ix)
tm.assert_series_equal(left, right)
def test_resample_across_dst():
# The test resamples a DatetimeIndex with values before and after a
# DST change
# Issue: 14682
# The DatetimeIndex we will start with
# (note that DST happens at 03:00+02:00 -> 02:00+01:00)
# 2016-10-30 02:23:00+02:00, 2016-10-30 02:23:00+01:00
df1 = DataFrame([1477786980, 1477790580], columns=["ts"])
dti1 = DatetimeIndex(
pd.to_datetime(df1.ts, unit="s")
.dt.tz_localize("UTC")
.dt.tz_convert("Europe/Madrid")
)
# The expected DatetimeIndex after resampling.
# 2016-10-30 02:00:00+02:00, 2016-10-30 02:00:00+01:00
df2 = DataFrame([1477785600, 1477789200], columns=["ts"])
dti2 = DatetimeIndex(
pd.to_datetime(df2.ts, unit="s")
.dt.tz_localize("UTC")
.dt.tz_convert("Europe/Madrid"),
freq="H",
)
df = DataFrame([5, 5], index=dti1)
result = df.resample(rule="H").sum()
expected = DataFrame([5, 5], index=dti2)
tm.assert_frame_equal(result, expected)
def test_groupby_with_dst_time_change():
# GH 24972
index = DatetimeIndex(
[1478064900001000000, 1480037118776792000], tz="UTC"
).tz_convert("America/Chicago")
df = DataFrame([1, 2], index=index)
result = df.groupby(Grouper(freq="1d")).last()
expected_index_values = date_range(
"2016-11-02", "2016-11-24", freq="d", tz="America/Chicago"
)
index = DatetimeIndex(expected_index_values)
expected = DataFrame([1.0] + ([np.nan] * 21) + [2.0], index=index)
tm.assert_frame_equal(result, expected)
def test_resample_dst_anchor():
# 5172
dti = DatetimeIndex([datetime(2012, 11, 4, 23)], tz="US/Eastern")
df = DataFrame([5], index=dti)
dti = DatetimeIndex(df.index.normalize(), freq="D")
expected = DataFrame([5], index=dti)
tm.assert_frame_equal(df.resample(rule="D").sum(), expected)
df.resample(rule="MS").sum()
tm.assert_frame_equal(
df.resample(rule="MS").sum(),
DataFrame(
[5],
index=DatetimeIndex([datetime(2012, 11, 1)], tz="US/Eastern", freq="MS"),
),
)
dti = date_range("2013-09-30", "2013-11-02", freq="30Min", tz="Europe/Paris")
values = range(dti.size)
df = DataFrame({"a": values, "b": values, "c": values}, index=dti, dtype="int64")
how = {"a": "min", "b": "max", "c": "count"}
tm.assert_frame_equal(
df.resample("W-MON").agg(how)[["a", "b", "c"]],
DataFrame(
{
"a": [0, 48, 384, 720, 1056, 1394],
"b": [47, 383, 719, 1055, 1393, 1586],
"c": [48, 336, 336, 336, 338, 193],
},
index=date_range("9/30/2013", "11/4/2013", freq="W-MON", tz="Europe/Paris"),
),
"W-MON Frequency",
)
tm.assert_frame_equal(
df.resample("2W-MON").agg(how)[["a", "b", "c"]],
DataFrame(
{
"a": [0, 48, 720, 1394],
"b": [47, 719, 1393, 1586],
"c": [48, 672, 674, 193],
},
index=date_range(
"9/30/2013", "11/11/2013", freq="2W-MON", tz="Europe/Paris"
),
),
"2W-MON Frequency",
)
tm.assert_frame_equal(
df.resample("MS").agg(how)[["a", "b", "c"]],
DataFrame(
{"a": [0, 48, 1538], "b": [47, 1537, 1586], "c": [48, 1490, 49]},
index=date_range("9/1/2013", "11/1/2013", freq="MS", tz="Europe/Paris"),
),
"MS Frequency",
)
tm.assert_frame_equal(
df.resample("2MS").agg(how)[["a", "b", "c"]],
DataFrame(
{"a": [0, 1538], "b": [1537, 1586], "c": [1538, 49]},
index=date_range("9/1/2013", "11/1/2013", freq="2MS", tz="Europe/Paris"),
),
"2MS Frequency",
)
df_daily = df["10/26/2013":"10/29/2013"]
tm.assert_frame_equal(
df_daily.resample("D").agg({"a": "min", "b": "max", "c": "count"})[
["a", "b", "c"]
],
DataFrame(
{
"a": [1248, 1296, 1346, 1394],
"b": [1295, 1345, 1393, 1441],
"c": [48, 50, 48, 48],
},
index=date_range("10/26/2013", "10/29/2013", freq="D", tz="Europe/Paris"),
),
"D Frequency",
)
def test_downsample_across_dst():
# GH 8531
tz = pytz.timezone("Europe/Berlin")
dt = datetime(2014, 10, 26)
dates = date_range(tz.localize(dt), periods=4, freq="2H")
result = Series(5, index=dates).resample("H").mean()
expected = Series(
[5.0, np.nan] * 3 + [5.0],
index=date_range(tz.localize(dt), periods=7, freq="H"),
)
tm.assert_series_equal(result, expected)
def test_downsample_across_dst_weekly():
# GH 9119, GH 21459
df = DataFrame(
index=DatetimeIndex(
["2017-03-25", "2017-03-26", "2017-03-27", "2017-03-28", "2017-03-29"],
tz="Europe/Amsterdam",
),
data=[11, 12, 13, 14, 15],
)
result = df.resample("1W").sum()
expected = DataFrame(
[23, 42],
index=DatetimeIndex(
["2017-03-26", "2017-04-02"], tz="Europe/Amsterdam", freq="W"
),
)
tm.assert_frame_equal(result, expected)
idx = date_range("2013-04-01", "2013-05-01", tz="Europe/London", freq="H")
s = Series(index=idx, dtype=np.float64)
result = s.resample("W").mean()
expected = Series(
index=date_range("2013-04-07", freq="W", periods=5, tz="Europe/London"),
dtype=np.float64,
)
tm.assert_series_equal(result, expected)
def test_downsample_dst_at_midnight():
# GH 25758
start = datetime(2018, 11, 3, 12)
end = datetime(2018, 11, 5, 12)
index = date_range(start, end, freq="1H")
index = index.tz_localize("UTC").tz_convert("America/Havana")
data = list(range(len(index)))
dataframe = DataFrame(data, index=index)
result = dataframe.groupby(Grouper(freq="1D")).mean()
dti = date_range("2018-11-03", periods=3).tz_localize(
"America/Havana", ambiguous=True
)
dti = DatetimeIndex(dti, freq="D")
expected = DataFrame([7.5, 28.0, 44.5], index=dti)
tm.assert_frame_equal(result, expected)
def test_resample_with_nat():
# GH 13020
index = DatetimeIndex(
[
pd.NaT,
"1970-01-01 00:00:00",
pd.NaT,
"1970-01-01 00:00:01",
"1970-01-01 00:00:02",
]
)
frame = DataFrame([2, 3, 5, 7, 11], index=index)
index_1s = DatetimeIndex(
["1970-01-01 00:00:00", "1970-01-01 00:00:01", "1970-01-01 00:00:02"]
)
frame_1s = DataFrame([3.0, 7.0, 11.0], index=index_1s)
tm.assert_frame_equal(frame.resample("1s").mean(), frame_1s)
index_2s = DatetimeIndex(["1970-01-01 00:00:00", "1970-01-01 00:00:02"])
frame_2s = DataFrame([5.0, 11.0], index=index_2s)
tm.assert_frame_equal(frame.resample("2s").mean(), frame_2s)
index_3s = DatetimeIndex(["1970-01-01 00:00:00"])
frame_3s = DataFrame([7.0], index=index_3s)
tm.assert_frame_equal(frame.resample("3s").mean(), frame_3s)
tm.assert_frame_equal(frame.resample("60s").mean(), frame_3s)
def test_resample_datetime_values():
# GH 13119
# check that datetime dtype is preserved when NaT values are
# introduced by the resampling
dates = [datetime(2016, 1, 15), datetime(2016, 1, 19)]
df = DataFrame({"timestamp": dates}, index=dates)
exp = Series(
[datetime(2016, 1, 15), pd.NaT, datetime(2016, 1, 19)],
index=date_range("2016-01-15", periods=3, freq="2D"),
name="timestamp",
)
res = df.resample("2D").first()["timestamp"]
tm.assert_series_equal(res, exp)
res = df["timestamp"].resample("2D").first()
tm.assert_series_equal(res, exp)
def test_resample_apply_with_additional_args(series):
# GH 14615
def f(data, add_arg):
return np.mean(data) * add_arg
multiplier = 10
result = series.resample("D").apply(f, multiplier)
expected = series.resample("D").mean().multiply(multiplier)
tm.assert_series_equal(result, expected)
# Testing as kwarg
result = series.resample("D").apply(f, add_arg=multiplier)
expected = series.resample("D").mean().multiply(multiplier)
tm.assert_series_equal(result, expected)
# Testing dataframe
df = DataFrame({"A": 1, "B": 2}, index=date_range("2017", periods=10))
result = df.groupby("A").resample("D").agg(f, multiplier).astype(float)
expected = df.groupby("A").resample("D").mean().multiply(multiplier)
# TODO: GH 41137
expected = expected.astype("float64")
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize("k", [1, 2, 3])
@pytest.mark.parametrize(
"n1, freq1, n2, freq2",
[
(30, "S", 0.5, "Min"),
(60, "S", 1, "Min"),
(3600, "S", 1, "H"),
(60, "Min", 1, "H"),
(21600, "S", 0.25, "D"),
(86400, "S", 1, "D"),
(43200, "S", 0.5, "D"),
(1440, "Min", 1, "D"),
(12, "H", 0.5, "D"),
(24, "H", 1, "D"),
],
)
def test_resample_equivalent_offsets(n1, freq1, n2, freq2, k):
# GH 24127
n1_ = n1 * k
n2_ = n2 * k
s = Series(0, index=date_range("19910905 13:00", "19911005 07:00", freq=freq1))
s = s + range(len(s))
result1 = s.resample(str(n1_) + freq1).mean()
result2 = s.resample(str(n2_) + freq2).mean()
tm.assert_series_equal(result1, result2)
@pytest.mark.parametrize(
"first,last,freq,exp_first,exp_last",
[
("19910905", "19920406", "D", "19910905", "19920407"),
("19910905 00:00", "19920406 06:00", "D", "19910905", "19920407"),
("19910905 06:00", "19920406 06:00", "H", "19910905 06:00", "19920406 07:00"),
("19910906", "19920406", "M", "19910831", "19920430"),
("19910831", "19920430", "M", "19910831", "19920531"),
("1991-08", "1992-04", "M", "19910831", "19920531"),
],
)
def test_get_timestamp_range_edges(first, last, freq, exp_first, exp_last):
first = Period(first)
first = first.to_timestamp(first.freq)
last = Period(last)
last = last.to_timestamp(last.freq)
exp_first = Timestamp(exp_first, freq=freq)
exp_last = Timestamp(exp_last, freq=freq)
freq = pd.tseries.frequencies.to_offset(freq)
result = _get_timestamp_range_edges(first, last, freq)
expected = (exp_first, exp_last)
assert result == expected
@pytest.mark.parametrize("duplicates", [True, False])
def test_resample_apply_product(duplicates):
# GH 5586
index = date_range(start="2012-01-31", freq="M", periods=12)
ts = Series(range(12), index=index)
df = DataFrame({"A": ts, "B": ts + 2})
if duplicates:
df.columns = ["A", "A"]
result = df.resample("Q").apply(np.product)
expected = DataFrame(
np.array([[0, 24], [60, 210], [336, 720], [990, 1716]], dtype=np.int64),
index=DatetimeIndex(
["2012-03-31", "2012-06-30", "2012-09-30", "2012-12-31"], freq="Q-DEC"
),
columns=df.columns,
)
tm.assert_frame_equal(result, expected)
@pytest.mark.parametrize(
"first,last,freq_in,freq_out,exp_last",
[
(
"2020-03-28",
"2020-03-31",
"D",
"24H",
"2020-03-30 01:00",
), # includes transition into DST
(
"2020-03-28",
"2020-10-27",
"D",
"24H",
"2020-10-27 00:00",
), # includes transition into and out of DST
(
"2020-10-25",
"2020-10-27",
"D",
"24H",
"2020-10-26 23:00",
), # includes transition out of DST
(
"2020-03-28",
"2020-03-31",
"24H",
"D",
"2020-03-30 00:00",
), # same as above, but from 24H to D
("2020-03-28", "2020-10-27", "24H", "D", "2020-10-27 00:00"),
("2020-10-25", "2020-10-27", "24H", "D", "2020-10-26 00:00"),
],
)
def test_resample_calendar_day_with_dst(
first: str, last: str, freq_in: str, freq_out: str, exp_last: str
):
# GH 35219
ts = Series(1.0, date_range(first, last, freq=freq_in, tz="Europe/Amsterdam"))
result = ts.resample(freq_out).pad()
expected = Series(
1.0, date_range(first, exp_last, freq=freq_out, tz="Europe/Amsterdam")
)
tm.assert_series_equal(result, expected)
@pytest.mark.parametrize("func", ["min", "max", "first", "last"])
def test_resample_aggregate_functions_min_count(func):
# GH#37768
index = date_range(start="2020", freq="M", periods=3)
ser = Series([1, np.nan, np.nan], index)
result = getattr(ser.resample("Q"), func)(min_count=2)
expected = Series(
[np.nan],
index=DatetimeIndex(["2020-03-31"], dtype="datetime64[ns]", freq="Q-DEC"),
)
tm.assert_series_equal(result, expected)
| bsd-3-clause |
scienceopen/radioutils | RainAttenuation.py | 1 | 3601 | #!/usr/bin/env python
"""
Plots reference figures from
https://www.itu.int/dms_pubrec/itu-r/rec/p/R-REC-P.838-3-200503-I!!PDF-E.pdf
and normally used to give rain attenuation vs. frequency
NOTE: to make this useful over a satellite-ground path,
consider factors like rain vs. altitude!
Example plot: 1-1000 GHz, 40 degree elevation angle, 10 mm/hour, vertical polarization (90 deg):
./RainAttenuation.py 10 -1 90 40
"""
import numpy as np
from matplotlib.pyplot import figure, show
from argparse import ArgumentParser
from radioutils.impairments import _rain_coeff, rain_attenuation
def main():
p = ArgumentParser()
p.add_argument("rainrate", help="rain rate [mm/hour]", type=float)
p.add_argument(
"freqHz",
help="frequency in Hz. Specifying -1 gives full-range frequency sweep plot",
type=float,
)
p.add_argument(
"polarizationDegrees",
help="polarization angle 0==horiz, 90==vert, 45==circ [degrees]",
type=float,
)
p.add_argument("elevationDegrees", help="elevation angle above horizon [degrees]", type=float)
p.add_argument("-v", "--verbose", help="reproduce report plots", action="store_true")
P = p.parse_args()
if P.freqHz <= 0 or P.verbose:
f = np.logspace(9, 12, 200)
dBkm = get_rain_atten(f, P.rainrate, P.polarizationDegrees, P.elevationDegrees, P.verbose)
ax = figure().gca()
ax.loglog(f / 1e9, dBkm)
ax.set_title(
f"ITU-R P.838-3 Rain attenuation\n {P.rainrate} mm/hour, elevation {P.elevationDegrees} degrees"
)
ax.set_xlabel("frequency [GHz]")
ax.set_ylabel("rain attenuation [dB/km]")
ax.grid(True, which="both")
show()
else:
f = P.freqHz
dBkm = get_rain_atten(f, P.rainrate, P.polarizationDegrees, P.elevationDegrees)
print(f"{dBkm:0.2e} dB/km attenuation")
def get_rain_atten(f, rainrate, polarization, elevation, verbose=False):
""" replicate figures from ITU report """
rain_atten_dBkm = rain_attenuation(f, rainrate, polarization, elevation)
if verbose:
ah, kh = _rain_coeff(f, "h", 0.0)
# %% Figure 1
ax = figure(1).gca()
ax.loglog(f / 1e9, kh)
ax.grid(True, which="both")
ax.set_title(r"Figure 1, $k$ coefficient for horizontal polarization")
ax.set_xlabel("frequency [GHz]")
ax.set_ylabel("$k_h$")
ax.set_ylim(1e-5, 10)
ax.set_xlim(1, 1000)
# %% Figure 2
ax = figure(2).gca()
ax.semilogx(f / 1e9, ah)
ax.grid(True, which="both")
ax.set_title(r"Figure 2, $\alpha$ coefficient for horizontal polarization")
ax.set_xlabel("frequency [GHz]")
ax.set_ylabel(r"$\alpha_h$")
ax.set_ylim(0.4, 1.8)
ax.set_xlim(1, 1000)
# %%
av, kv = _rain_coeff(f, "v", 0.0)
# %%
ax = figure(3).gca()
ax.loglog(f / 1e9, kv)
ax.grid(True, which="both")
ax.set_title(r"Figure 3, $k$ coefficient for vertical polarization")
ax.set_xlabel("frequency [GHz]")
ax.set_ylabel("$k_v$")
ax.set_ylim(1e-5, 10)
ax.set_xlim(1, 1000)
# %%
ax = figure(4).gca()
ax.semilogx(f / 1e9, av)
ax.grid(True, which="both")
ax.set_title(r"Figure 4, $\alpha$ coefficient for vertical polarization")
ax.set_xlabel("frequency [GHz]")
ax.set_ylabel(r"$\alpha_v$")
ax.set_ylim(0.4, 1.8)
ax.set_xlim(1, 1000)
return rain_atten_dBkm
if __name__ == "__main__":
main()
| gpl-3.0 |
mcanthony/Cello | benchmarks/graphs.py | 4 | 2204 | import numpy as np
from matplotlib import pyplot as plt
languages = np.array([
'C', 'C++', 'Cello',
'Java', 'Javascript', 'Python',
'Ruby', 'Lua', 'Lua JIT'])
experiments = [
'Array', 'Map', 'N-Bodies',
'Dictionary', 'Sudoku', 'Matrix',
'Garbage Collection']
results_array = np.array([
0.02, 0.02, 0.10,
0.14, 0.07, 0.11,
0.07, 2.34, 0.24])
results_map = np.array([
0.24, 0.05, 0.54,
0.60, 1.92, 9.73,
1.24, 5.46, 2.01])
results_nbodies = np.array([
0.01, 0.01, 0.07,
0.07, 0.09, 1.52,
1.45, 0.66, 0.02])
results_dict = np.array([
0.09, 0.13, 0.25,
0.24, 0.46, 0.18,
0.44, 0.23, 0.18])
results_sudoku = np.array([
0.14, 0.14, 0.15,
0.29, 0.44, 5.30,
9.64, 6.34, 0.49])
results_matrix = np.array([
0.03, 0.01, 0.02,
0.11, 0.23, 2.33,
7.62, 0.94, 0.03])
results_gc = np.array([
0.01, 0.01, 0.26,
0.06, 0.25, 3.34,
5.37, 8.02, 0.31])
results = [
results_array, results_map, results_nbodies,
results_dict, results_sudoku, results_matrix,
results_gc]
#cols = [
# '#006666', '#FF6600', '#991F00',
# '#339933', '#009999', '#006666',
# '#FF6600', '#991F00', '#339933']
cols = [
'#006666', '#FF6600', '#991F00',
'#006666', '#FF6600', '#991F00',
'#006666', '#FF6600', '#991F00']
ylims = [
3.25, 13.5, 2.2,
0.65, 13.5, 11, 11
]
for exp, result, ylim in zip(experiments, results, ylims):
fig = plt.figure(figsize=(3, 2.5))
ax = fig.add_subplot(1, 1, 1, axisbg='#FCFCFC')
bars = ax.bar(np.arange(len(result)), result)
for bar, col in zip(bars, cols):
bar.set_color(col)
bar.set_edgecolor('#555555')
height = bar.get_height()
ax.text(
bar.get_x()+bar.get_width()/1.5,
height + (ylim/20), '%0.2f' % height,
ha='center', va='bottom', rotation='vertical',
color='#555555')
plt.xticks(np.arange(len(result)) + 0.75 / 2, languages, rotation='vertical')
plt.gca().xaxis.grid(False)
plt.gca().yaxis.grid(False)
plt.ylim((0, ylim))
plt.tight_layout()
plt.show()
| bsd-2-clause |
darcyabjones/bioplotlib | setup.py | 1 | 1165 | """A setuptools based setup module.
See:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
config = {
'name': 'bioplotlib',
'version': '0.0.1',
'description': long_description,
'author': 'Darcy Jones',
'author_email': '[email protected]',
'url': 'https://github.com/darcyabjones/bioplotlib',
'download_url': 'https://github.com/darcyabjones/bioplotlib',
'packages': find_packages(),
'install_requires': ['numpy', 'matplotlib'],
'scripts': [],
'extras_require': {
'dev': ['check-manifest'],
'test': ['coverage', 'pytest', 'tox'],
},
'package_data': {
'bioplotlib': ['data/*.json', 'data/*.csv', 'data/*.pkl'],
},
'include_package_data': True,
}
setup(**config)
| bsd-3-clause |
pnedunuri/scikit-learn | examples/cluster/plot_mean_shift.py | 351 | 1793 | """
=============================================
A demo of the mean-shift clustering algorithm
=============================================
Reference:
Dorin Comaniciu and Peter Meer, "Mean Shift: A robust approach toward
feature space analysis". IEEE Transactions on Pattern Analysis and
Machine Intelligence. 2002. pp. 603-619.
"""
print(__doc__)
import numpy as np
from sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.datasets.samples_generator import make_blobs
###############################################################################
# Generate sample data
centers = [[1, 1], [-1, -1], [1, -1]]
X, _ = make_blobs(n_samples=10000, centers=centers, cluster_std=0.6)
###############################################################################
# Compute clustering with MeanShift
# The following bandwidth can be automatically detected using
bandwidth = estimate_bandwidth(X, quantile=0.2, n_samples=500)
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
labels_unique = np.unique(labels)
n_clusters_ = len(labels_unique)
print("number of estimated clusters : %d" % n_clusters_)
###############################################################################
# Plot result
import matplotlib.pyplot as plt
from itertools import cycle
plt.figure(1)
plt.clf()
colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk')
for k, col in zip(range(n_clusters_), colors):
my_members = labels == k
cluster_center = cluster_centers[k]
plt.plot(X[my_members, 0], X[my_members, 1], col + '.')
plt.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col,
markeredgecolor='k', markersize=14)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()
| bsd-3-clause |
taynaud/sparkit-learn | splearn/feature_extraction/text.py | 2 | 25038 | # -*- coding: utf-8 -*-
import numbers
import operator
from itertools import chain
import numpy as np
import scipy.sparse as sp
import six
from pyspark import AccumulatorParam
from sklearn.feature_extraction.text import (CountVectorizer,
HashingVectorizer,
TfidfTransformer,
_document_frequency,
_make_int_array)
from sklearn.utils.fixes import frombuffer_empty
from sklearn.utils.validation import check_is_fitted
from ..base import SparkBroadcasterMixin
from ..rdd import DictRDD
from ..utils.validation import check_rdd
class SparkCountVectorizer(CountVectorizer, SparkBroadcasterMixin):
"""Distributed implementation of CountVectorizer.
Convert a collection of text documents to a matrix of token counts
This implementation produces a sparse representation of the counts using
scipy.sparse.coo_matrix.
If you do not provide an a-priori dictionary and you do not use an analyzer
that does some kind of feature selection then the number of features will
be equal to the vocabulary size found by analyzing the data.
Parameters
----------
input : string {'filename', 'file', 'content'}
If 'filename', the sequence passed as an argument to fit is
expected to be a list of filenames that need reading to fetch
the raw content to analyze.
If 'file', the sequence items must have a 'read' method (file-like
object) that is called to fetch the bytes in memory.
Otherwise the input is expected to be the sequence strings or
bytes items are expected to be analyzed directly.
encoding : string, 'utf-8' by default.
If bytes or files are given to analyze, this encoding is used to
decode.
decode_error : {'strict', 'ignore', 'replace'}
Instruction on what to do if a byte sequence is given to analyze that
contains characters not of the given `encoding`. By default, it is
'strict', meaning that a UnicodeDecodeError will be raised. Other
values are 'ignore' and 'replace'.
strip_accents : {'ascii', 'unicode', None}
Remove accents during the preprocessing step.
'ascii' is a fast method that only works on characters that have
an direct ASCII mapping.
'unicode' is a slightly slower method that works on any characters.
None (default) does nothing.
analyzer : string, {'word', 'char', 'char_wb'} or callable
Whether the feature should be made of word or character n-grams.
Option 'char_wb' creates character n-grams only from text inside
word boundaries.
If a callable is passed it is used to extract the sequence of features
out of the raw, unprocessed input.
preprocessor : callable or None (default)
Override the preprocessing (string transformation) stage while
preserving the tokenizing and n-grams generation steps.
tokenizer : callable or None (default)
Override the string tokenization step while preserving the
preprocessing and n-grams generation steps.
ngram_range : tuple (min_n, max_n)
The lower and upper boundary of the range of n-values for different
n-grams to be extracted. All values of n such that min_n <= n <= max_n
will be used.
stop_words : string {'english'}, list, or None (default)
If 'english', a built-in stop word list for English is used.
If a list, that list is assumed to contain stop words, all of which
will be removed from the resulting tokens.
If None, no stop words will be used. max_df can be set to a value
in the range [0.7, 1.0) to automatically detect and filter stop
words based on intra corpus document frequency of terms.
lowercase : boolean, True by default
Convert all characters to lowercase before tokenizing.
token_pattern : string
Regular expression denoting what constitutes a "token", only used
if `tokenize == 'word'`. The default regexp select tokens of 2
or more alphanumeric characters (punctuation is completely ignored
and always treated as a token separator).
max_df : float in range [0.0, 1.0] or int, optional, 1.0 by default
When building the vocabulary ignore terms that have a document
frequency strictly higher than the given threshold (corpus-specific
stop words).
If float, the parameter represents a proportion of documents, integer
absolute counts.
This parameter is ignored if vocabulary is not None.
min_df : float in range [0.0, 1.0] or int, optional, 1 by default
When building the vocabulary ignore terms that have a document
frequency strictly lower than the given threshold. This value is also
called cut-off in the literature.
If float, the parameter represents a proportion of documents, integer
absolute counts.
This parameter is ignored if vocabulary is not None.
max_features : optional, None by default
If not None, build a vocabulary that only consider the top
max_features ordered by term frequency across the corpus.
This parameter is ignored if vocabulary is not None.
vocabulary : Mapping or iterable, optional
Either a Mapping (e.g., a dict) where keys are terms and values are
indices in the feature matrix, or an iterable over terms. If not
given, a vocabulary is determined from the input documents. Indices
in the mapping should not be repeated and should not have any gap
between 0 and the largest index.
binary : boolean, False by default.
If True, all non zero counts are set to 1. This is useful for discrete
probabilistic models that model binary events rather than integer
counts.
dtype : type, optional
Type of the matrix returned by fit_transform() or transform().
Attributes
----------
vocabulary_ : dict
A mapping of terms to feature indices.
stop_words_ : set
Terms that were ignored because
they occurred in either too many
(`max_df`) or in too few (`min_df`) documents.
This is only available if no vocabulary was given.
See also
--------
HashingVectorizer, TfidfVectorizer
"""
__transient__ = ['vocabulary_']
def to_scikit(self):
obj = CountVectorizer([])
obj.__dict__ = self.__dict__
return obj
def _init_vocab(self, analyzed_docs):
"""Create vocabulary
"""
class SetAccum(AccumulatorParam):
def zero(self, initialValue):
return set(initialValue)
def addInPlace(self, v1, v2):
v1 |= v2
return v1
if not self.fixed_vocabulary_:
accum = analyzed_docs._rdd.context.accumulator(set(), SetAccum())
analyzed_docs.foreach(
lambda x: accum.add(set(chain.from_iterable(x))))
vocabulary = {t: i for i, t in enumerate(accum.value)}
else:
vocabulary = self.vocabulary_
if not vocabulary:
raise ValueError("empty vocabulary; perhaps the documents only"
" contain stop words")
return vocabulary
def _count_vocab(self, analyzed_docs):
"""Create sparse feature matrix, and vocabulary where fixed_vocab=False
"""
vocabulary = self.vocabulary_
j_indices = _make_int_array()
indptr = _make_int_array()
indptr.append(0)
for doc in analyzed_docs:
for feature in doc:
try:
j_indices.append(vocabulary[feature])
except KeyError:
# Ignore out-of-vocabulary items for fixed_vocab=True
continue
indptr.append(len(j_indices))
j_indices = frombuffer_empty(j_indices, dtype=np.intc)
indptr = np.frombuffer(indptr, dtype=np.intc)
values = np.ones(len(j_indices))
X = sp.csr_matrix((values, j_indices, indptr),
shape=(len(indptr) - 1, len(vocabulary)),
dtype=self.dtype)
X.sum_duplicates()
if self.binary:
X.data.fill(1)
return X
def _sort_features(self, vocabulary):
"""Sort features by name
Returns a reordered matrix and modifies the vocabulary in place
"""
sorted_features = sorted(six.iteritems(vocabulary))
map_index = np.empty(len(sorted_features), dtype=np.int32)
for new_val, (term, old_val) in enumerate(sorted_features):
map_index[new_val] = old_val
vocabulary[term] = new_val
return map_index
def _limit_features(self, X, vocabulary, high=None, low=None,
limit=None):
"""Remove too rare or too common features.
Prune features that are non zero in more samples than high or less
documents than low, modifying the vocabulary, and restricting it to
at most the limit most frequent.
This does not prune samples with zero features.
"""
if high is None and low is None and limit is None:
return X, set()
# Calculate a mask based on document frequencies
dfs = X.map(_document_frequency).sum()
tfs = X.map(lambda x: np.asarray(x.sum(axis=0))).sum().ravel()
mask = np.ones(len(dfs), dtype=bool)
if high is not None:
mask &= dfs <= high
if low is not None:
mask &= dfs >= low
if limit is not None and mask.sum() > limit:
mask_inds = (-tfs[mask]).argsort()[:limit]
new_mask = np.zeros(len(dfs), dtype=bool)
new_mask[np.where(mask)[0][mask_inds]] = True
mask = new_mask
new_indices = np.cumsum(mask) - 1 # maps old indices to new
removed_terms = set()
for term, old_index in list(six.iteritems(vocabulary)):
if mask[old_index]:
vocabulary[term] = new_indices[old_index]
else:
del vocabulary[term]
removed_terms.add(term)
kept_indices = np.where(mask)[0]
if len(kept_indices) == 0:
raise ValueError("After pruning, no terms remain. Try a lower"
" min_df or a higher max_df.")
return kept_indices, removed_terms
def fit(self, Z):
"""Learn a vocabulary dictionary of all tokens in the raw documents in
the DictRDD's 'X' column.
Parameters
----------
raw_documents : iterable or DictRDD with column 'X'
An iterable which yields either str, unicode or file objects; or a
DictRDD with column 'X' containing such iterables.
Returns
-------
self
"""
self.fit_transform(Z)
return self
def fit_transform(self, Z):
"""Learn the vocabulary dictionary and return term-document matrix.
This is equivalent to fit followed by transform, but more efficiently
implemented.
Parameters
----------
Z : iterable or DictRDD with column 'X'
An iterable of raw_documents which yields either str, unicode or
file objects; or a DictRDD with column 'X' containing such
iterables.
Returns
-------
X : array, [n_samples, n_features] or DictRDD
Document-term matrix.
"""
self._validate_vocabulary()
# map analyzer and cache result
analyze = self.build_analyzer()
A = Z.transform(lambda X: list(map(analyze, X)), column='X').persist()
# create vocabulary
X = A[:, 'X'] if isinstance(A, DictRDD) else A
self.vocabulary_ = self._init_vocab(X)
# transform according to vocabulary
mapper = self.broadcast(self._count_vocab, A.context)
Z = A.transform(mapper, column='X', dtype=sp.spmatrix)
if not self.fixed_vocabulary_:
X = Z[:, 'X'] if isinstance(Z, DictRDD) else Z
max_df = self.max_df
min_df = self.min_df
max_features = self.max_features
# limit features according to min_df, max_df parameters
n_doc = X.shape[0]
max_doc_count = (max_df
if isinstance(max_df, numbers.Integral)
else max_df * n_doc)
min_doc_count = (min_df
if isinstance(min_df, numbers.Integral)
else min_df * n_doc)
if max_doc_count < min_doc_count:
raise ValueError(
"max_df corresponds to < documents than min_df")
kept_indices, self.stop_words_ = self._limit_features(
X, self.vocabulary_, max_doc_count, min_doc_count, max_features)
# sort features
map_index = self._sort_features(self.vocabulary_)
# combined mask
mask = kept_indices[map_index]
Z = Z.transform(lambda x: x[:, mask], column='X', dtype=sp.spmatrix)
A.unpersist()
return Z
def transform(self, Z):
"""Transform documents to document-term matrix.
Extract token counts out of raw text documents using the vocabulary
fitted with fit or the one provided to the constructor.
Parameters
----------
raw_documents : iterable
An iterable which yields either str, unicode or file objects.
Returns
-------
X : sparse matrix, [n_samples, n_features]
Document-term matrix.
"""
if not hasattr(self, 'vocabulary_'):
self._validate_vocabulary()
self._check_vocabulary()
analyze = self.build_analyzer()
mapper = self.broadcast(self._count_vocab, Z.context)
Z = Z.transform(lambda X: list(map(analyze, X)), column='X') \
.transform(mapper, column='X', dtype=sp.spmatrix)
return Z
class SparkHashingVectorizer(HashingVectorizer):
"""Distributed implementation of Hashingvectorizer.
Convert a collection of text documents to a matrix of token occurrences
It turns a collection of text documents into a scipy.sparse matrix holding
token occurrence counts (or binary occurrence information), possibly
normalized as token frequencies if norm='l1' or projected on the euclidean
unit sphere if norm='l2'.
This text vectorizer implementation uses the hashing trick to find the
token string name to feature integer index mapping.
This strategy has several advantages:
- it is very low memory scalable to large datasets as there is no need to
store a vocabulary dictionary in memory
- it is fast to pickle and un-pickle as it holds no state besides the
constructor parameters
- it can be used in a streaming (partial fit) or parallel pipeline as there
is no state computed during fit.
There are also a couple of cons (vs using a CountVectorizer with an
in-memory vocabulary):
- there is no way to compute the inverse transform (from feature indices to
string feature names) which can be a problem when trying to introspect
which features are most important to a model.
- there can be collisions: distinct tokens can be mapped to the same
feature index. However in practice this is rarely an issue if n_features
is large enough (e.g. 2 ** 18 for text classification problems).
- no IDF weighting as this would render the transformer stateful.
The hash function employed is the signed 32-bit version of Murmurhash3.
Parameters
----------
input: string {'filename', 'file', 'content'}
If 'filename', the sequence passed as an argument to fit is
expected to be a list of filenames that need reading to fetch
the raw content to analyze.
If 'file', the sequence items must have a 'read' method (file-like
object) that is called to fetch the bytes in memory.
Otherwise the input is expected to be the sequence strings or
bytes items are expected to be analyzed directly.
encoding : string, 'utf-8' by default.
If bytes or files are given to analyze, this encoding is used to
decode.
decode_error : {'strict', 'ignore', 'replace'}
Instruction on what to do if a byte sequence is given to analyze that
contains characters not of the given `encoding`. By default, it is
'strict', meaning that a UnicodeDecodeError will be raised. Other
values are 'ignore' and 'replace'.
strip_accents: {'ascii', 'unicode', None}
Remove accents during the preprocessing step.
'ascii' is a fast method that only works on characters that have
an direct ASCII mapping.
'unicode' is a slightly slower method that works on any characters.
None (default) does nothing.
analyzer: string, {'word', 'char', 'char_wb'} or callable
Whether the feature should be made of word or character n-grams.
Option 'char_wb' creates character n-grams only from text inside
word boundaries.
If a callable is passed it is used to extract the sequence of features
out of the raw, unprocessed input.
preprocessor: callable or None (default)
Override the preprocessing (string transformation) stage while
preserving the tokenizing and n-grams generation steps.
tokenizer: callable or None (default)
Override the string tokenization step while preserving the
preprocessing and n-grams generation steps.
ngram_range: tuple (min_n, max_n)
The lower and upper boundary of the range of n-values for different
n-grams to be extracted. All values of n such that min_n <= n <= max_n
will be used.
stop_words: string {'english'}, list, or None (default)
If 'english', a built-in stop word list for English is used.
If a list, that list is assumed to contain stop words, all of which
will be removed from the resulting tokens.
lowercase: boolean, default True
Convert all characters to lowercase before tokenizing.
token_pattern: string
Regular expression denoting what constitutes a "token", only used
if `analyzer == 'word'`. The default regexp selects tokens of 2
or more alphanumeric characters (punctuation is completely ignored
and always treated as a token separator).
n_features : integer, optional, (2 ** 20) by default
The number of features (columns) in the output matrices. Small numbers
of features are likely to cause hash collisions, but large numbers
will cause larger coefficient dimensions in linear learners.
norm : 'l1', 'l2' or None, optional
Norm used to normalize term vectors. None for no normalization.
binary: boolean, False by default.
If True, all non zero counts are set to 1. This is useful for discrete
probabilistic models that model binary events rather than integer
counts.
dtype: type, optional
Type of the matrix returned by fit_transform() or transform().
non_negative : boolean, optional
Whether output matrices should contain non-negative values only;
effectively calls abs on the matrix prior to returning it.
When True, output values can be interpreted as frequencies.
When False, output values will have expected value zero.
See also
--------
CountVectorizer, TfidfVectorizer
"""
def transform(self, Z):
"""Transform an ArrayRDD (or DictRDD with column 'X') containing
sequence of documents to a document-term matrix.
Parameters
----------
Z : ArrayRDD or DictRDD with raw text documents
Samples. Each sample must be a text document (either bytes or
unicode strings) which will be tokenized and hashed.
Returns
-------
Z : SparseRDD/DictRDD containg scipy.sparse matrix
Document-term matrix.
"""
mapper = super(SparkHashingVectorizer, self).transform
return Z.transform(mapper, column='X', dtype=sp.spmatrix)
fit_transform = transform
def to_scikit(self):
obj = HashingVectorizer()
obj.__dict__ = self.__dict__
return obj
class SparkTfidfTransformer(TfidfTransformer, SparkBroadcasterMixin):
"""Distributed implementation of TfidfTransformer.
Transform a count matrix to a normalized tf or tf-idf representation
Tf means term-frequency while tf-idf means term-frequency times inverse
document-frequency. This is a common term weighting scheme in information
retrieval, that has also found good use in document classification.
The goal of using tf-idf instead of the raw frequencies of occurrence of a
token in a given document is to scale down the impact of tokens that occur
very frequently in a given corpus and that are hence empirically less
informative than features that occur in a small fraction of the training
corpus.
The actual formula used for tf-idf is tf * (idf + 1) = tf + tf * idf,
instead of tf * idf. The effect of this is that terms with zero idf, i.e.
that occur in all documents of a training set, will not be entirely
ignored. The formulas used to compute tf and idf depend on parameter
settings that correspond to the SMART notation used in IR, as follows:
Tf is "n" (natural) by default, "l" (logarithmic) when sublinear_tf=True.
Idf is "t" when use_idf is given, "n" (none) otherwise.
Normalization is "c" (cosine) when norm='l2', "n" (none) when norm=None.
Parameters
----------
norm : 'l1', 'l2' or None, optional
Norm used to normalize term vectors. None for no normalization.
use_idf : boolean, optional
Enable inverse-document-frequency reweighting.
smooth_idf : boolean, optional
Smooth idf weights by adding one to document frequencies, as if an
extra document was seen containing every term in the collection
exactly once. Prevents zero divisions.
sublinear_tf : boolean, optional
Apply sublinear tf scaling, i.e. replace tf with 1 + log(tf).
References
----------
.. [Yates2011] `R. Baeza-Yates and B. Ribeiro-Neto (2011). Modern
Information Retrieval. Addison Wesley, pp. 68-74.`
.. [MRS2008] `C.D. Manning, P. Raghavan and H. Schuetze (2008).
Introduction to Information Retrieval. Cambridge University
Press, pp. 118-120.`
"""
__transient__ = ['_idf_diag']
def fit(self, Z):
"""Learn the idf vector (global term weights)
Parameters
----------
Z : ArrayRDD or DictRDD containing (sparse matrices|ndarray)
a matrix of term/token counts
Returns
-------
self : TfidfVectorizer
"""
X = Z[:, 'X'] if isinstance(Z, DictRDD) else Z
check_rdd(X, (sp.spmatrix, np.ndarray))
def mapper(X, use_idf=self.use_idf):
if not sp.issparse(X):
X = sp.csc_matrix(X)
if use_idf:
return _document_frequency(X)
if self.use_idf:
n_samples, n_features = X.shape
df = X.map(mapper).treeReduce(operator.add)
# perform idf smoothing if required
df += int(self.smooth_idf)
n_samples += int(self.smooth_idf)
# log1p instead of log makes sure terms with zero idf don't get
# suppressed entirely
idf = np.log(float(n_samples) / df) + 1.0
self._idf_diag = sp.spdiags(idf,
diags=0, m=n_features, n=n_features)
return self
def transform(self, Z):
"""Transform an ArrayRDD (or DictRDD's 'X' column) containing count
matrices to a tf or tf-idf representation
Parameters
----------
Z : ArrayRDD/DictRDD with sparse matrices
a matrix of term/token counts
Returns
-------
Z : SparseRDD/DictRDD containing sparse matrices
"""
X = Z[:, 'X'] if isinstance(Z, DictRDD) else Z
check_rdd(X, (sp.spmatrix, np.ndarray))
mapper = super(SparkTfidfTransformer, self).transform
if self.use_idf:
check_is_fitted(self, '_idf_diag', 'idf vector is not fitted')
mapper = self.broadcast(mapper, Z.context)
return Z.transform(mapper, column='X', dtype=sp.spmatrix)
def to_scikit(self):
obj = TfidfTransformer()
obj.__dict__ = self.__dict__
return obj
| apache-2.0 |
shakamunyi/tensorflow | tensorflow/examples/skflow/digits.py | 9 | 2380 | # 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.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from sklearn import datasets, cross_validation, metrics
import tensorflow as tf
from tensorflow.contrib import learn
from tensorflow.contrib.learn import monitors
# Load dataset
digits = datasets.load_digits()
X = digits.images
y = digits.target
# Split it into train / test subsets
X_train, X_test, y_train, y_test = cross_validation.train_test_split(X, y,
test_size=0.2,
random_state=42)
# Split X_train again to create validation data
X_train, X_val, y_train, y_val = cross_validation.train_test_split(X_train,
y_train,
test_size=0.2,
random_state=42)
# TensorFlow model using Scikit Flow ops
def conv_model(X, y):
X = tf.expand_dims(X, 3)
features = tf.reduce_max(tf.contrib.layers.conv2d(X, 12, [3, 3]), [1, 2])
features = tf.reshape(features, [-1, 12])
return learn.models.logistic_regression(features, y)
val_monitor = monitors.ValidationMonitor(X_val, y_val, every_n_steps=50)
# Create a classifier, train and predict.
classifier = learn.TensorFlowEstimator(model_fn=conv_model, n_classes=10,
steps=1000, learning_rate=0.05,
batch_size=128)
classifier.fit(X_train, y_train, monitors=[val_monitor])
score = metrics.accuracy_score(y_test, classifier.predict(X_test))
print('Test Accuracy: {0:f}'.format(score))
| apache-2.0 |
Shekharrajak/pydy | examples/double_pendulum/scipy/double_pendulum_integration.py | 8 | 3476 | #!/usr/bin/env python
# This is an example of integrating the equations of motion for a double
# pendulum which were generated with sympy.physics.mechanics. We make use of
# SciPy/NumPy for the integration routines and Matplotlib for plotting.
#
# Steps taken:
# 1. Turned on mechanics_printing() in sympy.physics.mechanics for proper
# output for copying the equations to this file.
# 2. Import zeros, sin, cos, linspace from NumPy, odeint from SciPy and pyplot
# from Matplotlib.
# 3. Write a function definition that returns the right hand side of the
# first order form of the equations of motion. rhd(y, t, *parameters)
# 4. Called odeint with rhs, y0, t and the parameters.
# 5. Plotted the results.
from numpy import sin, cos, linspace, zeros
import matplotlib.pyplot as plt
from scipy.integrate import odeint
## Integration ##
def rhs(y, t, l, m, g):
"""Returns the derivatives of the states at the given time for the given
set of parameters.
Parameters
----------
y : array_like, shape(n,)
An array of the current states.
t : float
The current time.
l : float
Pendulum length.
m : float
Pendulum mass.
g : float
Acceleration due to gravity.
Returns
-------
dydt : array_like, shape(n,)
An array of the current derivatives of the states.
Notes
-----
The units and order of the states, time and parameters should be
consistent.
"""
# Unpack the states so you can use the variable names in the
# sympy.physics.mechanics equations
q1 = y[0]
q2 = y[1]
u1 = y[2]
u2 = y[3]
# or you can make use of python's tuple unpacking for a one liner
# q1, q2, u1, u2 = y
# Initialize a vector for the derivatives.
dydt = zeros((len(y)))
# Compute the derivatives, these are pasted in from the
# sympy.physics.mechanics results.
dydt[0] = u1
dydt[1] = u2
dydt[2] = (-g*sin(q1)*sin(q2)**2 + 2*g*sin(q1) -
g*sin(q2)*cos(q1)*cos(q2) + 2*l*u1**2*sin(q1)*cos(q1)*cos(q2)**2 -
l*u1**2*sin(q1)*cos(q1) - 2*l*u1**2*sin(q2)*cos(q1)**2*cos(q2) +
l*u1**2*sin(q2)*cos(q2) + l*u2**2*sin(q1)*cos(q2) -
l*u2**2*sin(q2)*cos(q1))/(l*(sin(q1)**2*sin(q2)**2 +
2*sin(q1)*sin(q2)*cos(q1)*cos(q2) + cos(q1)**2*cos(q2)**2 - 2))
dydt[3] = (-sin(q1)*sin(q2)/2 - cos(q1)*cos(q2)/2)*(2*g*l*m*sin(q1) -
l**2*m*(-sin(q1)*cos(q2) +
sin(q2)*cos(q1))*u2**2)/(l**2*m*(sin(q1)*sin(q2)/2 +
cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2)) -
l**2*m) + (g*l*m*sin(q2) - l**2*m*(sin(q1)*cos(q2) -
sin(q2)*cos(q1))*u1**2)/(l**2*m*(sin(q1)*sin(q2)/2 +
cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2))
- l**2*m)
# Return the derivatives.
return dydt
# Specify the length, mass and acceleration due to gravity.
parameters = (1, 1, 9.8)
# Specify initial conditions for the states.
y0 = [.1, .2, 0, 0]
# Create a time vector.
t = linspace(0, 5)
# Integrate the equations of motion.
y = odeint(rhs, y0, t, parameters)
## Plotting ##
# Create an empty figure.
fig = plt.figure()
# Add a single axes to the figure.
ax = fig.add_subplot(1, 1, 1)
# Plot the states versus time.
ax.plot(t, y)
# Add a title, axes labels and a legend.
ax.set_title('Double Pendulum Example')
ax.set_xlabel('Time (s)')
ax.set_ylabel('Angle, Angluar rate (rad, rad/s)')
ax.legend(['q1', 'q2', 'u1', 'u2'])
# Display the figure.
plt.show()
| bsd-3-clause |
CoderHam/Machine_Learning_Projects | final_project/tester.py | 2 | 4224 | #!/usr/bin/pickle
""" a basic script for importing student's POI identifier,
and checking the results that they get from it
requires that the algorithm, dataset, and features list
be written to my_classifier.pkl, my_dataset.pkl, and
my_feature_list.pkl, respectively
that process should happen at the end of poi_id.py
"""
import pickle
import sys
from sklearn.cross_validation import StratifiedShuffleSplit
sys.path.append("../tools/")
from feature_format import featureFormat, targetFeatureSplit
PERF_FORMAT_STRING = "\
\tAccuracy: {:>0.{display_precision}f}\tPrecision: {:>0.{display_precision}f}\t\
Recall: {:>0.{display_precision}f}\tF1: {:>0.{display_precision}f}\tF2: {:>0.{display_precision}f}"
RESULTS_FORMAT_STRING = "\tTotal predictions: {:4d}\tTrue positives: {:4d}\tFalse positives: {:4d}\tFalse negatives: {:4d}\tTrue negatives: {:4d}"
def test_classifier(clf, dataset, feature_list, folds = 1000):
data = featureFormat(dataset, feature_list, sort_keys = True)
labels, features = targetFeatureSplit(data)
cv = StratifiedShuffleSplit(labels, folds, random_state = 42)
true_negatives = 0
false_negatives = 0
true_positives = 0
false_positives = 0
for train_idx, test_idx in cv:
features_train = []
features_test = []
labels_train = []
labels_test = []
for ii in train_idx:
features_train.append( features[ii] )
labels_train.append( labels[ii] )
for jj in test_idx:
features_test.append( features[jj] )
labels_test.append( labels[jj] )
### fit the classifier using training set, and test on test set
clf.fit(features_train, labels_train)
predictions = clf.predict(features_test)
for prediction, truth in zip(predictions, labels_test):
if prediction == 0 and truth == 0:
true_negatives += 1
elif prediction == 0 and truth == 1:
false_negatives += 1
elif prediction == 1 and truth == 0:
false_positives += 1
elif prediction == 1 and truth == 1:
true_positives += 1
else:
print "Warning: Found a predicted label not == 0 or 1."
print "All predictions should take value 0 or 1."
print "Evaluating performance for processed predictions:"
break
try:
total_predictions = true_negatives + false_negatives + false_positives + true_positives
accuracy = 1.0*(true_positives + true_negatives)/total_predictions
precision = 1.0*true_positives/(true_positives+false_positives)
recall = 1.0*true_positives/(true_positives+false_negatives)
f1 = 2.0 * true_positives/(2*true_positives + false_positives+false_negatives)
f2 = (1+2.0*2.0) * precision*recall/(4*precision + recall)
print clf
print PERF_FORMAT_STRING.format(accuracy, precision, recall, f1, f2, display_precision = 5)
print RESULTS_FORMAT_STRING.format(total_predictions, true_positives, false_positives, false_negatives, true_negatives)
print ""
except:
print "Got a divide by zero when trying out:", clf
print "Precision or recall may be undefined due to a lack of true positive predicitons."
CLF_PICKLE_FILENAME = "my_classifier.pkl"
DATASET_PICKLE_FILENAME = "my_dataset.pkl"
FEATURE_LIST_FILENAME = "my_feature_list.pkl"
def dump_classifier_and_data(clf, dataset, feature_list):
pickle.dump(clf, open(CLF_PICKLE_FILENAME, "w") )
pickle.dump(dataset, open(DATASET_PICKLE_FILENAME, "w") )
pickle.dump(feature_list, open(FEATURE_LIST_FILENAME, "w") )
def load_classifier_and_data():
clf = pickle.load(open(CLF_PICKLE_FILENAME, "r") )
dataset = pickle.load(open(DATASET_PICKLE_FILENAME, "r") )
feature_list = pickle.load(open(FEATURE_LIST_FILENAME, "r"))
return clf, dataset, feature_list
def main():
### load up student's classifier, dataset, and feature_list
clf, dataset, feature_list = load_classifier_and_data()
### Run testing script
test_classifier(clf, dataset, feature_list)
if __name__ == '__main__':
main()
| gpl-2.0 |
vandenheuvel/tribler | TriblerGUI/widgets/trustpageplot.py | 1 | 4966 | import matplotlib
from TriblerGUI.defs import PAGE_MARKET
matplotlib.use('Qt5Agg')
import datetime
from PyQt5.QtWidgets import QSizePolicy
from PyQt5.QtWidgets import QWidget
from matplotlib.backends.backend_qt5agg import FigureCanvas
from matplotlib.dates import DateFormatter
from matplotlib.figure import Figure
from TriblerGUI.tribler_request_manager import TriblerRequestManager
class MplCanvas(FigureCanvas):
"""Ultimately, this is a QWidget."""
def __init__(self, parent=None, width=5, height=5, dpi=100):
fig = Figure(figsize=(width, height), dpi=dpi)
fig.set_facecolor("#282828")
fig.set_tight_layout({"pad": 1})
self.axes = fig.add_subplot(111)
self.plot_data = None
FigureCanvas.__init__(self, fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def compute_initial_figure(self):
pass
class TrustPlotMplCanvas(MplCanvas):
def compute_initial_figure(self):
self.axes.cla()
self.axes.set_title("MBytes given/taken over time", color="#e0e0e0")
self.axes.set_xlabel("Date")
self.axes.set_ylabel("Given/taken data (MBytes)")
self.axes.xaxis.set_major_formatter(DateFormatter('%d-%m-%y'))
self.axes.plot(self.plot_data[1], self.plot_data[0][0], label="MBytes given", marker='o')
self.axes.plot(self.plot_data[1], self.plot_data[0][1], label="MBytes taken", marker='o')
self.axes.grid(True)
for line in self.axes.get_xgridlines() + self.axes.get_ygridlines():
line.set_linestyle('--')
# Color the axes
if hasattr(self.axes, 'set_facecolor'): # Not available on Linux
self.axes.set_facecolor('#464646')
self.axes.xaxis.label.set_color('#e0e0e0')
self.axes.yaxis.label.set_color('#e0e0e0')
self.axes.tick_params(axis='x', colors='#e0e0e0')
self.axes.tick_params(axis='y', colors='#e0e0e0')
# Create the legend
handles, labels = self.axes.get_legend_handles_labels()
self.axes.legend(handles, labels)
if len(self.plot_data[0][0]) == 1: # If we only have one data point, don't show negative axis
self.axes.set_ylim(-0.3, 10)
self.axes.set_xlim(datetime.datetime.now() - datetime.timedelta(hours=1),
datetime.datetime.now() + datetime.timedelta(days=4))
self.draw()
class TrustPagePlot(QWidget):
"""
This page shows various trust statistics.
"""
def __init__(self):
QWidget.__init__(self)
self.trust_plot = None
self.public_key = None
self.request_mgr = None
self.statistics = None
self.blocks = None
self.byte_scale = 1024 * 1024
def initialize_trust_page(self):
vlayout = self.window().plot_widget.layout()
self.trust_plot = TrustPlotMplCanvas(self.window().plot_widget, dpi=100)
vlayout.addWidget(self.trust_plot)
def load_trust_statistics(self):
self.request_mgr = TriblerRequestManager()
self.request_mgr.perform_request("trustchain/statistics", self.received_trustchain_statistics)
def received_trustchain_statistics(self, statistics):
statistics = statistics["statistics"]
self.window().trust_contribution_amount_label.setText("%s MBytes" % (statistics["total_up"] / self.byte_scale))
self.window().trust_consumption_amount_label.setText("%s MBytes" % (statistics["total_down"] / self.byte_scale))
self.window().trust_people_helped_label.setText("%d" % statistics["peers_that_pk_helped"])
self.window().trust_people_helped_you_label.setText("%d" % statistics["peers_that_helped_pk"])
# Fetch the latest blocks of this user
self.public_key = statistics["id"]
self.request_mgr = TriblerRequestManager()
self.request_mgr.perform_request("trustchain/blocks/%s" % self.public_key, self.received_trustchain_blocks)
def received_trustchain_blocks(self, blocks):
self.blocks = blocks["blocks"]
self.plot_absolute_values()
def plot_absolute_values(self):
"""
Plot two lines of the absolute amounts of contributed and consumed bytes.
"""
plot_data = [[[], []], []]
# Convert all dates to a datetime object
for block in self.blocks:
plot_data[1].append(datetime.datetime.strptime(block["insert_time"], "%Y-%m-%d %H:%M:%S"))
plot_data[0][0].append(block["total_up"] / self.byte_scale)
plot_data[0][1].append(block["total_down"] / self.byte_scale)
if len(self.blocks) == 0:
# Create on single data point with 0mb up and 0mb down
plot_data = [[[0], [0]], [datetime.datetime.now()]]
self.trust_plot.plot_data = plot_data
self.trust_plot.compute_initial_figure()
| lgpl-3.0 |
murali-munna/scikit-learn | sklearn/neighbors/classification.py | 106 | 13987 | """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.
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, **kwargs):
self._init_params(n_neighbors=n_neighbors,
algorithm=algorithm,
leaf_size=leaf_size, metric=metric, p=p,
metric_params=metric_params, **kwargs)
self.weights = _check_weights(weights)
def predict(self, X):
"""Predict the class labels for the provided data
Parameters
----------
X : array of shape [n_samples, n_features]
A 2-D array representing the test points.
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, shape = (n_samples, n_features)
A 2-D array representing the test points.
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 of shape [n_samples, n_features]
A 2-D array representing the test points.
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 |
jakobworldpeace/scikit-learn | benchmarks/bench_sample_without_replacement.py | 397 | 8008 | """
Benchmarks for sampling without replacement of integer.
"""
from __future__ import division
from __future__ import print_function
import gc
import sys
import optparse
from datetime import datetime
import operator
import matplotlib.pyplot as plt
import numpy as np
import random
from sklearn.externals.six.moves import xrange
from sklearn.utils.random import sample_without_replacement
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_sample(sampling, n_population, n_samples):
gc.collect()
# start time
t_start = datetime.now()
sampling(n_population, n_samples)
delta = (datetime.now() - t_start)
# stop time
time = compute_time(t_start, delta)
return time
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-population",
dest="n_population", default=100000, type=int,
help="Size of the population to sample from.")
op.add_option("--n-step",
dest="n_steps", default=5, type=int,
help="Number of step interval between 0 and n_population.")
default_algorithms = "custom-tracking-selection,custom-auto," \
"custom-reservoir-sampling,custom-pool,"\
"python-core-sample,numpy-permutation"
op.add_option("--algorithm",
dest="selected_algorithm",
default=default_algorithms,
type=str,
help="Comma-separated list of transformer to benchmark. "
"Default: %default. \nAvailable: %default")
# op.add_option("--random-seed",
# dest="random_seed", default=13, type=int,
# help="Seed used by the random number generators.")
(opts, args) = op.parse_args()
if len(args) > 0:
op.error("this script takes no arguments.")
sys.exit(1)
selected_algorithm = opts.selected_algorithm.split(',')
for key in selected_algorithm:
if key not in default_algorithms.split(','):
raise ValueError("Unknown sampling algorithm \"%s\" not in (%s)."
% (key, default_algorithms))
###########################################################################
# List sampling algorithm
###########################################################################
# We assume that sampling algorithm has the following signature:
# sample(n_population, n_sample)
#
sampling_algorithm = {}
###########################################################################
# Set Python core input
sampling_algorithm["python-core-sample"] = \
lambda n_population, n_sample: \
random.sample(xrange(n_population), n_sample)
###########################################################################
# Set custom automatic method selection
sampling_algorithm["custom-auto"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="auto",
random_state=random_state)
###########################################################################
# Set custom tracking based method
sampling_algorithm["custom-tracking-selection"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="tracking_selection",
random_state=random_state)
###########################################################################
# Set custom reservoir based method
sampling_algorithm["custom-reservoir-sampling"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="reservoir_sampling",
random_state=random_state)
###########################################################################
# Set custom reservoir based method
sampling_algorithm["custom-pool"] = \
lambda n_population, n_samples, random_state=None: \
sample_without_replacement(n_population,
n_samples,
method="pool",
random_state=random_state)
###########################################################################
# Numpy permutation based
sampling_algorithm["numpy-permutation"] = \
lambda n_population, n_sample: \
np.random.permutation(n_population)[:n_sample]
###########################################################################
# Remove unspecified algorithm
sampling_algorithm = dict((key, value)
for key, value in sampling_algorithm.items()
if key in selected_algorithm)
###########################################################################
# Perform benchmark
###########################################################################
time = {}
n_samples = np.linspace(start=0, stop=opts.n_population,
num=opts.n_steps).astype(np.int)
ratio = n_samples / opts.n_population
print('Benchmarks')
print("===========================")
for name in sorted(sampling_algorithm):
print("Perform benchmarks for %s..." % name, end="")
time[name] = np.zeros(shape=(opts.n_steps, opts.n_times))
for step in xrange(opts.n_steps):
for it in xrange(opts.n_times):
time[name][step, it] = bench_sample(sampling_algorithm[name],
opts.n_population,
n_samples[step])
print("done")
print("Averaging results...", end="")
for name in sampling_algorithm:
time[name] = np.mean(time[name], axis=1)
print("done\n")
# 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("Sampling algorithm performance:")
print("===============================")
print("Results are averaged over %s repetition(s)." % opts.n_times)
print("")
fig = plt.figure('scikit-learn sample w/o replacement benchmark results')
plt.title("n_population = %s, n_times = %s" %
(opts.n_population, opts.n_times))
ax = fig.add_subplot(111)
for name in sampling_algorithm:
ax.plot(ratio, time[name], label=name)
ax.set_xlabel('ratio of n_sample / n_population')
ax.set_ylabel('Time (s)')
ax.legend()
# Sort legend labels
handles, labels = ax.get_legend_handles_labels()
hl = sorted(zip(handles, labels), key=operator.itemgetter(1))
handles2, labels2 = zip(*hl)
ax.legend(handles2, labels2, loc=0)
plt.show()
| bsd-3-clause |
rishikksh20/scikit-learn | sklearn/feature_selection/tests/test_mutual_info.py | 30 | 6881 | from __future__ import division
import numpy as np
from numpy.testing import run_module_suite
from scipy.sparse import csr_matrix
from sklearn.utils.testing import (assert_array_equal, assert_almost_equal,
assert_false, assert_raises, assert_equal,
assert_allclose, assert_greater)
from sklearn.feature_selection.mutual_info_ import (
mutual_info_regression, mutual_info_classif, _compute_mi)
def test_compute_mi_dd():
# In discrete case computations are straightforward and can be done
# by hand on given vectors.
x = np.array([0, 1, 1, 0, 0])
y = np.array([1, 0, 0, 0, 1])
H_x = H_y = -(3/5) * np.log(3/5) - (2/5) * np.log(2/5)
H_xy = -1/5 * np.log(1/5) - 2/5 * np.log(2/5) - 2/5 * np.log(2/5)
I_xy = H_x + H_y - H_xy
assert_almost_equal(_compute_mi(x, y, True, True), I_xy)
def test_compute_mi_cc():
# For two continuous variables a good approach is to test on bivariate
# normal distribution, where mutual information is known.
# Mean of the distribution, irrelevant for mutual information.
mean = np.zeros(2)
# Setup covariance matrix with correlation coeff. equal 0.5.
sigma_1 = 1
sigma_2 = 10
corr = 0.5
cov = np.array([
[sigma_1**2, corr * sigma_1 * sigma_2],
[corr * sigma_1 * sigma_2, sigma_2**2]
])
# True theoretical mutual information.
I_theory = (np.log(sigma_1) + np.log(sigma_2) -
0.5 * np.log(np.linalg.det(cov)))
np.random.seed(0)
Z = np.random.multivariate_normal(mean, cov, size=1000)
x, y = Z[:, 0], Z[:, 1]
# Theory and computed values won't be very close, assert that the
# first figures after decimal point match.
for n_neighbors in [3, 5, 7]:
I_computed = _compute_mi(x, y, False, False, n_neighbors)
assert_almost_equal(I_computed, I_theory, 1)
def test_compute_mi_cd():
# To test define a joint distribution as follows:
# p(x, y) = p(x) p(y | x)
# X ~ Bernoulli(p)
# (Y | x = 0) ~ Uniform(-1, 1)
# (Y | x = 1) ~ Uniform(0, 2)
# Use the following formula for mutual information:
# I(X; Y) = H(Y) - H(Y | X)
# Two entropies can be computed by hand:
# H(Y) = -(1-p)/2 * ln((1-p)/2) - p/2*log(p/2) - 1/2*log(1/2)
# H(Y | X) = ln(2)
# Now we need to implement sampling from out distribution, which is
# done easily using conditional distribution logic.
n_samples = 1000
np.random.seed(0)
for p in [0.3, 0.5, 0.7]:
x = np.random.uniform(size=n_samples) > p
y = np.empty(n_samples)
mask = x == 0
y[mask] = np.random.uniform(-1, 1, size=np.sum(mask))
y[~mask] = np.random.uniform(0, 2, size=np.sum(~mask))
I_theory = -0.5 * ((1 - p) * np.log(0.5 * (1 - p)) +
p * np.log(0.5 * p) + np.log(0.5)) - np.log(2)
# Assert the same tolerance.
for n_neighbors in [3, 5, 7]:
I_computed = _compute_mi(x, y, True, False, n_neighbors)
assert_almost_equal(I_computed, I_theory, 1)
def test_compute_mi_cd_unique_label():
# Test that adding unique label doesn't change MI.
n_samples = 100
x = np.random.uniform(size=n_samples) > 0.5
y = np.empty(n_samples)
mask = x == 0
y[mask] = np.random.uniform(-1, 1, size=np.sum(mask))
y[~mask] = np.random.uniform(0, 2, size=np.sum(~mask))
mi_1 = _compute_mi(x, y, True, False)
x = np.hstack((x, 2))
y = np.hstack((y, 10))
mi_2 = _compute_mi(x, y, True, False)
assert_equal(mi_1, mi_2)
# We are going test that feature ordering by MI matches our expectations.
def test_mutual_info_classif_discrete():
X = np.array([[0, 0, 0],
[1, 1, 0],
[2, 0, 1],
[2, 0, 1],
[2, 0, 1]])
y = np.array([0, 1, 2, 2, 1])
# Here X[:, 0] is the most informative feature, and X[:, 1] is weakly
# informative.
mi = mutual_info_classif(X, y, discrete_features=True)
assert_array_equal(np.argsort(-mi), np.array([0, 2, 1]))
def test_mutual_info_regression():
# We generate sample from multivariate normal distribution, using
# transformation from initially uncorrelated variables. The zero
# variables after transformation is selected as the target vector,
# it has the strongest correlation with the variable 2, and
# the weakest correlation with the variable 1.
T = np.array([
[1, 0.5, 2, 1],
[0, 1, 0.1, 0.0],
[0, 0.1, 1, 0.1],
[0, 0.1, 0.1, 1]
])
cov = T.dot(T.T)
mean = np.zeros(4)
np.random.seed(0)
Z = np.random.multivariate_normal(mean, cov, size=1000)
X = Z[:, 1:]
y = Z[:, 0]
mi = mutual_info_regression(X, y, random_state=0)
assert_array_equal(np.argsort(-mi), np.array([1, 2, 0]))
def test_mutual_info_classif_mixed():
# Here the target is discrete and there are two continuous and one
# discrete feature. The idea of this test is clear from the code.
np.random.seed(0)
X = np.random.rand(1000, 3)
X[:, 1] += X[:, 0]
y = ((0.5 * X[:, 0] + X[:, 2]) > 0.5).astype(int)
X[:, 2] = X[:, 2] > 0.5
mi = mutual_info_classif(X, y, discrete_features=[2], n_neighbors=3,
random_state=0)
assert_array_equal(np.argsort(-mi), [2, 0, 1])
for n_neighbors in [5, 7, 9]:
mi_nn = mutual_info_classif(X, y, discrete_features=[2],
n_neighbors=n_neighbors, random_state=0)
# Check that the continuous values have an higher MI with greater
# n_neighbors
assert_greater(mi_nn[0], mi[0])
assert_greater(mi_nn[1], mi[1])
# The n_neighbors should not have any effect on the discrete value
# The MI should be the same
assert_equal(mi_nn[2], mi[2])
def test_mutual_info_options():
X = np.array([[0, 0, 0],
[1, 1, 0],
[2, 0, 1],
[2, 0, 1],
[2, 0, 1]], dtype=float)
y = np.array([0, 1, 2, 2, 1], dtype=float)
X_csr = csr_matrix(X)
for mutual_info in (mutual_info_regression, mutual_info_classif):
assert_raises(ValueError, mutual_info_regression, X_csr, y,
discrete_features=False)
mi_1 = mutual_info(X, y, discrete_features='auto', random_state=0)
mi_2 = mutual_info(X, y, discrete_features=False, random_state=0)
mi_3 = mutual_info(X_csr, y, discrete_features='auto',
random_state=0)
mi_4 = mutual_info(X_csr, y, discrete_features=True,
random_state=0)
assert_array_equal(mi_1, mi_2)
assert_array_equal(mi_3, mi_4)
assert_false(np.allclose(mi_1, mi_3))
if __name__ == '__main__':
run_module_suite()
| bsd-3-clause |
Bulochkin/tensorflow_pack | tensorflow/contrib/learn/python/learn/dataframe/dataframe.py | 27 | 4836 | # 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.
# ==============================================================================
"""A DataFrame is a container for ingesting and preprocessing data."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import collections
from .series import Series
from .transform import Transform
from tensorflow.python.util.deprecation import deprecated
class DataFrame(object):
"""A DataFrame is a container for ingesting and preprocessing data."""
@deprecated("2017-06-15", "contrib/learn/dataframe/** is deprecated.")
def __init__(self):
self._columns = {}
def columns(self):
"""Set of the column names."""
return frozenset(self._columns.keys())
def __len__(self):
"""The number of columns in the DataFrame."""
return len(self._columns)
def assign(self, **kwargs):
"""Adds columns to DataFrame.
Args:
**kwargs: assignments of the form key=value where key is a string
and value is an `inflow.Series`, a `pandas.Series` or a numpy array.
Raises:
TypeError: keys are not strings.
TypeError: values are not `inflow.Series`, `pandas.Series` or
`numpy.ndarray`.
TODO(jamieas): pandas assign method returns a new DataFrame. Consider
switching to this behavior, changing the name or adding in_place as an
argument.
"""
for k, v in kwargs.items():
if not isinstance(k, str):
raise TypeError("The only supported type for keys is string; got %s" %
type(k))
if v is None:
del self._columns[k]
elif isinstance(v, Series):
self._columns[k] = v
elif isinstance(v, Transform) and v.input_valency() == 0:
self._columns[k] = v()
else:
raise TypeError(
"Column in assignment must be an inflow.Series, inflow.Transform,"
" or None; got type '%s'." % type(v).__name__)
def select_columns(self, keys):
"""Returns a new DataFrame with a subset of columns.
Args:
keys: A list of strings. Each should be the name of a column in the
DataFrame.
Returns:
A new DataFrame containing only the specified columns.
"""
result = type(self)()
for key in keys:
result[key] = self._columns[key]
return result
def exclude_columns(self, exclude_keys):
"""Returns a new DataFrame with all columns not excluded via exclude_keys.
Args:
exclude_keys: A list of strings. Each should be the name of a column in
the DataFrame. These columns will be excluded from the result.
Returns:
A new DataFrame containing all columns except those specified.
"""
result = type(self)()
for key, value in self._columns.items():
if key not in exclude_keys:
result[key] = value
return result
def __getitem__(self, key):
"""Indexing functionality for DataFrames.
Args:
key: a string or an iterable of strings.
Returns:
A Series or list of Series corresponding to the given keys.
"""
if isinstance(key, str):
return self._columns[key]
elif isinstance(key, collections.Iterable):
for i in key:
if not isinstance(i, str):
raise TypeError("Expected a String; entry %s has type %s." %
(i, type(i).__name__))
return [self.__getitem__(i) for i in key]
raise TypeError(
"Invalid index: %s of type %s. Only strings or lists of strings are "
"supported." % (key, type(key)))
def __setitem__(self, key, value):
if isinstance(key, str):
key = [key]
if isinstance(value, Series):
value = [value]
self.assign(**dict(zip(key, value)))
def __delitem__(self, key):
if isinstance(key, str):
key = [key]
value = [None for _ in key]
self.assign(**dict(zip(key, value)))
def build(self, **kwargs):
# We do not allow passing a cache here, because that would encourage
# working around the rule that DataFrames cannot be expected to be
# synced with each other (e.g., they shuffle independently).
cache = {}
tensors = {name: c.build(cache, **kwargs)
for name, c in self._columns.items()}
return tensors
| apache-2.0 |
ntnu-tdat2004/machine-learning | 2_linear_regression_3d_visualization.py | 1 | 3709 | import numpy as np
import matplotlib
matplotlib.use('TkAgg')
from mpl_toolkits.mplot3d import axes3d, art3d
import matplotlib.pyplot as plt
from matplotlib import cm
matplotlib.rcParams.update({'font.size': 11})
# regarding the notations, see http://stats.stackexchange.com/questions/193908/in-machine-learning-why-are-superscripts-used-instead-of-subscripts
W_init=np.mat([[-0.2], [0.53]])
b_init=np.mat([[3.1]])
class LinearRegressionModel:
def __init__(self, W=W_init.copy(), b=b_init.copy()):
self.W = W
self.b = b
# predictor
def f(self, x): return x * self.W + self.b
# uses Mean Squared Error. The error function is also sometimes called cost or loss function
def error(self, x, y): return np.sum(np.power(self.f(x) - y, 2))
model = LinearRegressionModel()
# observed/training input and output
x_train = np.mat([[1, 4.5], [1.5, 2], [2, 1], [3, 3.5], [4, 3], [5, 1], [6, 2]])
y_train = np.mat([[5], [3.5], [3], [4], [3], [1.5], [2]])
fig = plt.figure("Linear regression: 3D")
plot1 = fig.add_subplot(111, projection='3d')
plot1.plot(x_train[:,0].A.squeeze(), x_train[:,1].A.squeeze(), y_train[:,0].A.squeeze(), 'o', label="$(\\hat x_1^{(i)}, \\hat x_2^{(i)},\\hat y^{(i)})$", color="blue")
plot1_f = plot1.plot_wireframe(np.array([[]]), np.array([[]]), np.array([[]]), color="green", label="$y = f(x) = xW+b$")
plot1_info = fig.text(0.01, 0.02, "")
plot1_error=[]
for i in range(0, x_train.shape[0]):
line, = plot1.plot([0, 0], [0, 0], [0, 0], color="red")
plot1_error.append(line)
if i == 0:
line.set_label("$|f(\\hat x^{(i)})-\\hat y^{(i)}|$")
plot1.set_xlabel("$x_1$")
plot1.set_ylabel("$x_2$")
plot1.set_zlabel("$y$")
plot1.legend(loc="upper left")
plot1.set_xticks([])
plot1.set_yticks([])
plot1.set_zticks([])
plot1.w_xaxis.line.set_lw(0)
plot1.w_yaxis.line.set_lw(0)
plot1.w_zaxis.line.set_lw(0)
plot1.quiver([0], [0], [0], [np.max(x_train[:,0]+1)], [0], [0], arrow_length_ratio=0.05, color="black")
plot1.quiver([0], [0], [0], [0], [np.max(x_train[:,1]+1)], [0], arrow_length_ratio=0.05, color="black")
plot1.quiver([0], [0], [0], [0], [0], [np.max(y_train[:,0]+1)], arrow_length_ratio=0.05, color="black")
def update_figure(event=None):
if(event is not None):
if event.key == "W":
model.W[0,0]+=0.01
elif event.key == "w":
model.W[0,0]-=0.01
elif event.key == "E":
model.W[1,0]+=0.01
elif event.key == "e":
model.W[1,0]-=0.01
elif event.key == "B":
model.b[0,0]+=0.05
elif event.key == "b":
model.b[0,0]-=0.05
elif event.key == "c":
model.W=W_init.copy()
model.b=b_init.copy()
global plot1_f
plot1_f.remove()
x1_grid, x2_grid = np.meshgrid(np.linspace(1, 6, 10), np.linspace(1, 4.5, 10))
y_grid=np.empty([10, 10])
for i in range(0, x1_grid.shape[0]):
for j in range(0, x1_grid.shape[1]):
y_grid[i,j]=model.f([[x1_grid[i,j], x2_grid[i,j]]])
plot1_f = plot1.plot_wireframe(x1_grid, x2_grid, y_grid, color='green')
for i in range(0, x_train.shape[0]):
plot1_error[i].set_data([x_train[i,0], x_train[i,0]], [x_train[i,1], x_train[i,1]])
plot1_error[i].set_3d_properties([y_train[i,0], model.f(x_train[i,:])])
plot1_info.set_text("$W=\\left[\\stackrel{%.2f}{%.2f}\\right]$\n$b=[%.2f]$\n$error = \\sum_i(f(\\hat x^{(i)}) - \\hat y^{(i)})^2 = %.2f$" % (model.W[0,0], model.W[1,0], model.b[0,0], model.error(x_train, y_train)))
fig.canvas.draw()
update_figure()
fig.canvas.mpl_connect('key_press_event', update_figure)
plt.show()
| mit |
matthewfranglen/spark | python/pyspark/sql/dataframe.py | 4 | 91760 | #
# 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 sys
import random
if sys.version >= '3':
basestring = unicode = str
long = int
from functools import reduce
from html import escape as html_escape
else:
from itertools import imap as map
from cgi import escape as html_escape
import warnings
from pyspark import copy_func, since, _NoValue
from pyspark.rdd import RDD, _load_from_socket, _local_iterator_from_socket, \
ignore_unicode_prefix
from pyspark.serializers import BatchedSerializer, PickleSerializer, \
UTF8Deserializer
from pyspark.storagelevel import StorageLevel
from pyspark.traceback_utils import SCCallSiteSync
from pyspark.sql.types import _parse_datatype_json_string
from pyspark.sql.column import Column, _to_seq, _to_list, _to_java_column
from pyspark.sql.readwriter import DataFrameWriter
from pyspark.sql.streaming import DataStreamWriter
from pyspark.sql.types import *
from pyspark.sql.pandas.conversion import PandasConversionMixin
from pyspark.sql.pandas.map_ops import PandasMapOpsMixin
__all__ = ["DataFrame", "DataFrameNaFunctions", "DataFrameStatFunctions"]
class DataFrame(PandasMapOpsMixin, PandasConversionMixin):
"""A distributed collection of data grouped into named columns.
A :class:`DataFrame` is equivalent to a relational table in Spark SQL,
and can be created using various functions in :class:`SparkSession`::
people = spark.read.parquet("...")
Once created, it can be manipulated using the various domain-specific-language
(DSL) functions defined in: :class:`DataFrame`, :class:`Column`.
To select a column from the :class:`DataFrame`, use the apply method::
ageCol = people.age
A more concrete example::
# To create DataFrame using SparkSession
people = spark.read.parquet("...")
department = spark.read.parquet("...")
people.filter(people.age > 30).join(department, people.deptId == department.id) \\
.groupBy(department.name, "gender").agg({"salary": "avg", "age": "max"})
.. versionadded:: 1.3
"""
def __init__(self, jdf, sql_ctx):
self._jdf = jdf
self.sql_ctx = sql_ctx
self._sc = sql_ctx and sql_ctx._sc
self.is_cached = False
self._schema = None # initialized lazily
self._lazy_rdd = None
# Check whether _repr_html is supported or not, we use it to avoid calling _jdf twice
# by __repr__ and _repr_html_ while eager evaluation opened.
self._support_repr_html = False
@property
@since(1.3)
def rdd(self):
"""Returns the content as an :class:`pyspark.RDD` of :class:`Row`.
"""
if self._lazy_rdd is None:
jrdd = self._jdf.javaToPython()
self._lazy_rdd = RDD(jrdd, self.sql_ctx._sc, BatchedSerializer(PickleSerializer()))
return self._lazy_rdd
@property
@since("1.3.1")
def na(self):
"""Returns a :class:`DataFrameNaFunctions` for handling missing values.
"""
return DataFrameNaFunctions(self)
@property
@since(1.4)
def stat(self):
"""Returns a :class:`DataFrameStatFunctions` for statistic functions.
"""
return DataFrameStatFunctions(self)
@ignore_unicode_prefix
@since(1.3)
def toJSON(self, use_unicode=True):
"""Converts a :class:`DataFrame` into a :class:`RDD` of string.
Each row is turned into a JSON document as one element in the returned RDD.
>>> df.toJSON().first()
u'{"age":2,"name":"Alice"}'
"""
rdd = self._jdf.toJSON()
return RDD(rdd.toJavaRDD(), self._sc, UTF8Deserializer(use_unicode))
@since(1.3)
def registerTempTable(self, name):
"""Registers this DataFrame as a temporary table using the given name.
The lifetime of this temporary table is tied to the :class:`SparkSession`
that was used to create this :class:`DataFrame`.
>>> df.registerTempTable("people")
>>> df2 = spark.sql("select * from people")
>>> sorted(df.collect()) == sorted(df2.collect())
True
>>> spark.catalog.dropTempView("people")
.. note:: Deprecated in 2.0, use createOrReplaceTempView instead.
"""
warnings.warn(
"Deprecated in 2.0, use createOrReplaceTempView instead.", DeprecationWarning)
self._jdf.createOrReplaceTempView(name)
@since(2.0)
def createTempView(self, name):
"""Creates a local temporary view with this :class:`DataFrame`.
The lifetime of this temporary table is tied to the :class:`SparkSession`
that was used to create this :class:`DataFrame`.
throws :class:`TempTableAlreadyExistsException`, if the view name already exists in the
catalog.
>>> df.createTempView("people")
>>> df2 = spark.sql("select * from people")
>>> sorted(df.collect()) == sorted(df2.collect())
True
>>> df.createTempView("people") # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
AnalysisException: u"Temporary table 'people' already exists;"
>>> spark.catalog.dropTempView("people")
"""
self._jdf.createTempView(name)
@since(2.0)
def createOrReplaceTempView(self, name):
"""Creates or replaces a local temporary view with this :class:`DataFrame`.
The lifetime of this temporary table is tied to the :class:`SparkSession`
that was used to create this :class:`DataFrame`.
>>> df.createOrReplaceTempView("people")
>>> df2 = df.filter(df.age > 3)
>>> df2.createOrReplaceTempView("people")
>>> df3 = spark.sql("select * from people")
>>> sorted(df3.collect()) == sorted(df2.collect())
True
>>> spark.catalog.dropTempView("people")
"""
self._jdf.createOrReplaceTempView(name)
@since(2.1)
def createGlobalTempView(self, name):
"""Creates a global temporary view with this :class:`DataFrame`.
The lifetime of this temporary view is tied to this Spark application.
throws :class:`TempTableAlreadyExistsException`, if the view name already exists in the
catalog.
>>> df.createGlobalTempView("people")
>>> df2 = spark.sql("select * from global_temp.people")
>>> sorted(df.collect()) == sorted(df2.collect())
True
>>> df.createGlobalTempView("people") # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
AnalysisException: u"Temporary table 'people' already exists;"
>>> spark.catalog.dropGlobalTempView("people")
"""
self._jdf.createGlobalTempView(name)
@since(2.2)
def createOrReplaceGlobalTempView(self, name):
"""Creates or replaces a global temporary view using the given name.
The lifetime of this temporary view is tied to this Spark application.
>>> df.createOrReplaceGlobalTempView("people")
>>> df2 = df.filter(df.age > 3)
>>> df2.createOrReplaceGlobalTempView("people")
>>> df3 = spark.sql("select * from global_temp.people")
>>> sorted(df3.collect()) == sorted(df2.collect())
True
>>> spark.catalog.dropGlobalTempView("people")
"""
self._jdf.createOrReplaceGlobalTempView(name)
@property
@since(1.4)
def write(self):
"""
Interface for saving the content of the non-streaming :class:`DataFrame` out into external
storage.
:return: :class:`DataFrameWriter`
"""
return DataFrameWriter(self)
@property
@since(2.0)
def writeStream(self):
"""
Interface for saving the content of the streaming :class:`DataFrame` out into external
storage.
.. note:: Evolving.
:return: :class:`DataStreamWriter`
"""
return DataStreamWriter(self)
@property
@since(1.3)
def schema(self):
"""Returns the schema of this :class:`DataFrame` as a :class:`pyspark.sql.types.StructType`.
>>> df.schema
StructType(List(StructField(age,IntegerType,true),StructField(name,StringType,true)))
"""
if self._schema is None:
try:
self._schema = _parse_datatype_json_string(self._jdf.schema().json())
except AttributeError as e:
raise Exception(
"Unable to parse datatype from schema. %s" % e)
return self._schema
@since(1.3)
def printSchema(self):
"""Prints out the schema in the tree format.
>>> df.printSchema()
root
|-- age: integer (nullable = true)
|-- name: string (nullable = true)
<BLANKLINE>
"""
print(self._jdf.schema().treeString())
@since(1.3)
def explain(self, extended=None, mode=None):
"""Prints the (logical and physical) plans to the console for debugging purpose.
:param extended: boolean, default ``False``. If ``False``, prints only the physical plan.
:param mode: specifies the expected output format of plans.
* ``simple``: Print only a physical plan.
* ``extended``: Print both logical and physical plans.
* ``codegen``: Print a physical plan and generated codes if they are available.
* ``cost``: Print a logical plan and statistics if they are available.
* ``formatted``: Split explain output into two sections: a physical plan outline \
and node details.
>>> df.explain()
== Physical Plan ==
*(1) Scan ExistingRDD[age#0,name#1]
>>> df.explain(True)
== Parsed Logical Plan ==
...
== Analyzed Logical Plan ==
...
== Optimized Logical Plan ==
...
== Physical Plan ==
...
>>> df.explain(mode="formatted")
== Physical Plan ==
* Scan ExistingRDD (1)
(1) Scan ExistingRDD [codegen id : 1]
Output [2]: [age#0, name#1]
...
.. versionchanged:: 3.0.0
Added optional argument `mode` to specify the expected output format of plans.
"""
if extended is not None and mode is not None:
raise Exception("extended and mode can not be specified simultaneously")
# For the no argument case: df.explain()
is_no_argument = extended is None and mode is None
# For the cases below:
# explain(True)
# explain(extended=False)
is_extended_case = extended is not None and isinstance(extended, bool)
# For the mode specified: df.explain(mode="formatted")
is_mode_case = mode is not None and isinstance(mode, basestring)
if not is_no_argument and not (is_extended_case or is_mode_case):
if extended is not None:
err_msg = "extended (optional) should be provided as bool" \
", got {0}".format(type(extended))
else: # For mode case
err_msg = "mode (optional) should be provided as str, got {0}".format(type(mode))
raise TypeError(err_msg)
# Sets an explain mode depending on a given argument
if is_no_argument:
explain_mode = "simple"
elif is_extended_case:
explain_mode = "extended" if extended else "simple"
elif is_mode_case:
explain_mode = mode
print(self._sc._jvm.PythonSQLUtils.explainString(self._jdf.queryExecution(), explain_mode))
@since(2.4)
def exceptAll(self, other):
"""Return a new :class:`DataFrame` containing rows in this :class:`DataFrame` but
not in another :class:`DataFrame` while preserving duplicates.
This is equivalent to `EXCEPT ALL` in SQL.
>>> df1 = spark.createDataFrame(
... [("a", 1), ("a", 1), ("a", 1), ("a", 2), ("b", 3), ("c", 4)], ["C1", "C2"])
>>> df2 = spark.createDataFrame([("a", 1), ("b", 3)], ["C1", "C2"])
>>> df1.exceptAll(df2).show()
+---+---+
| C1| C2|
+---+---+
| a| 1|
| a| 1|
| a| 2|
| c| 4|
+---+---+
Also as standard in SQL, this function resolves columns by position (not by name).
"""
return DataFrame(self._jdf.exceptAll(other._jdf), self.sql_ctx)
@since(1.3)
def isLocal(self):
"""Returns ``True`` if the :func:`collect` and :func:`take` methods can be run locally
(without any Spark executors).
"""
return self._jdf.isLocal()
@property
@since(2.0)
def isStreaming(self):
"""Returns ``True`` if this :class:`Dataset` contains one or more sources that continuously
return data as it arrives. A :class:`Dataset` that reads data from a streaming source
must be executed as a :class:`StreamingQuery` using the :func:`start` method in
:class:`DataStreamWriter`. Methods that return a single answer, (e.g., :func:`count` or
:func:`collect`) will throw an :class:`AnalysisException` when there is a streaming
source present.
.. note:: Evolving
"""
return self._jdf.isStreaming()
@since(1.3)
def show(self, n=20, truncate=True, vertical=False):
"""Prints the first ``n`` rows to the console.
:param n: Number of rows to show.
:param truncate: If set to ``True``, truncate strings longer than 20 chars by default.
If set to a number greater than one, truncates long strings to length ``truncate``
and align cells right.
:param vertical: If set to ``True``, print output rows vertically (one line
per column value).
>>> df
DataFrame[age: int, name: string]
>>> df.show()
+---+-----+
|age| name|
+---+-----+
| 2|Alice|
| 5| Bob|
+---+-----+
>>> df.show(truncate=3)
+---+----+
|age|name|
+---+----+
| 2| Ali|
| 5| Bob|
+---+----+
>>> df.show(vertical=True)
-RECORD 0-----
age | 2
name | Alice
-RECORD 1-----
age | 5
name | Bob
"""
if isinstance(truncate, bool) and truncate:
print(self._jdf.showString(n, 20, vertical))
else:
print(self._jdf.showString(n, int(truncate), vertical))
def __repr__(self):
if not self._support_repr_html and self.sql_ctx._conf.isReplEagerEvalEnabled():
vertical = False
return self._jdf.showString(
self.sql_ctx._conf.replEagerEvalMaxNumRows(),
self.sql_ctx._conf.replEagerEvalTruncate(), vertical)
else:
return "DataFrame[%s]" % (", ".join("%s: %s" % c for c in self.dtypes))
def _repr_html_(self):
"""Returns a :class:`DataFrame` with html code when you enabled eager evaluation
by 'spark.sql.repl.eagerEval.enabled', this only called by REPL you are
using support eager evaluation with HTML.
"""
if not self._support_repr_html:
self._support_repr_html = True
if self.sql_ctx._conf.isReplEagerEvalEnabled():
max_num_rows = max(self.sql_ctx._conf.replEagerEvalMaxNumRows(), 0)
sock_info = self._jdf.getRowsToPython(
max_num_rows, self.sql_ctx._conf.replEagerEvalTruncate())
rows = list(_load_from_socket(sock_info, BatchedSerializer(PickleSerializer())))
head = rows[0]
row_data = rows[1:]
has_more_data = len(row_data) > max_num_rows
row_data = row_data[:max_num_rows]
html = "<table border='1'>\n"
# generate table head
html += "<tr><th>%s</th></tr>\n" % "</th><th>".join(map(lambda x: html_escape(x), head))
# generate table rows
for row in row_data:
html += "<tr><td>%s</td></tr>\n" % "</td><td>".join(
map(lambda x: html_escape(x), row))
html += "</table>\n"
if has_more_data:
html += "only showing top %d %s\n" % (
max_num_rows, "row" if max_num_rows == 1 else "rows")
return html
else:
return None
@since(2.1)
def checkpoint(self, eager=True):
"""Returns a checkpointed version of this Dataset. Checkpointing can be used to truncate the
logical plan of this :class:`DataFrame`, which is especially useful in iterative algorithms
where the plan may grow exponentially. It will be saved to files inside the checkpoint
directory set with :meth:`SparkContext.setCheckpointDir`.
:param eager: Whether to checkpoint this :class:`DataFrame` immediately
.. note:: Experimental
"""
jdf = self._jdf.checkpoint(eager)
return DataFrame(jdf, self.sql_ctx)
@since(2.3)
def localCheckpoint(self, eager=True):
"""Returns a locally checkpointed version of this Dataset. Checkpointing can be used to
truncate the logical plan of this :class:`DataFrame`, which is especially useful in
iterative algorithms where the plan may grow exponentially. Local checkpoints are
stored in the executors using the caching subsystem and therefore they are not reliable.
:param eager: Whether to checkpoint this :class:`DataFrame` immediately
.. note:: Experimental
"""
jdf = self._jdf.localCheckpoint(eager)
return DataFrame(jdf, self.sql_ctx)
@since(2.1)
def withWatermark(self, eventTime, delayThreshold):
"""Defines an event time watermark for this :class:`DataFrame`. A watermark tracks a point
in time before which we assume no more late data is going to arrive.
Spark will use this watermark for several purposes:
- To know when a given time window aggregation can be finalized and thus can be emitted
when using output modes that do not allow updates.
- To minimize the amount of state that we need to keep for on-going aggregations.
The current watermark is computed by looking at the `MAX(eventTime)` seen across
all of the partitions in the query minus a user specified `delayThreshold`. Due to the cost
of coordinating this value across partitions, the actual watermark used is only guaranteed
to be at least `delayThreshold` behind the actual event time. In some cases we may still
process records that arrive more than `delayThreshold` late.
:param eventTime: the name of the column that contains the event time of the row.
:param delayThreshold: the minimum delay to wait to data to arrive late, relative to the
latest record that has been processed in the form of an interval
(e.g. "1 minute" or "5 hours").
.. note:: Evolving
>>> sdf.select('name', sdf.time.cast('timestamp')).withWatermark('time', '10 minutes')
DataFrame[name: string, time: timestamp]
"""
if not eventTime or type(eventTime) is not str:
raise TypeError("eventTime should be provided as a string")
if not delayThreshold or type(delayThreshold) is not str:
raise TypeError("delayThreshold should be provided as a string interval")
jdf = self._jdf.withWatermark(eventTime, delayThreshold)
return DataFrame(jdf, self.sql_ctx)
@since(2.2)
def hint(self, name, *parameters):
"""Specifies some hint on the current :class:`DataFrame`.
:param name: A name of the hint.
:param parameters: Optional parameters.
:return: :class:`DataFrame`
>>> df.join(df2.hint("broadcast"), "name").show()
+----+---+------+
|name|age|height|
+----+---+------+
| Bob| 5| 85|
+----+---+------+
"""
if len(parameters) == 1 and isinstance(parameters[0], list):
parameters = parameters[0]
if not isinstance(name, str):
raise TypeError("name should be provided as str, got {0}".format(type(name)))
allowed_types = (basestring, list, float, int)
for p in parameters:
if not isinstance(p, allowed_types):
raise TypeError(
"all parameters should be in {0}, got {1} of type {2}".format(
allowed_types, p, type(p)))
jdf = self._jdf.hint(name, self._jseq(parameters))
return DataFrame(jdf, self.sql_ctx)
@since(1.3)
def count(self):
"""Returns the number of rows in this :class:`DataFrame`.
>>> df.count()
2
"""
return int(self._jdf.count())
@ignore_unicode_prefix
@since(1.3)
def collect(self):
"""Returns all the records as a list of :class:`Row`.
>>> df.collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
"""
with SCCallSiteSync(self._sc) as css:
sock_info = self._jdf.collectToPython()
return list(_load_from_socket(sock_info, BatchedSerializer(PickleSerializer())))
@ignore_unicode_prefix
@since(2.0)
def toLocalIterator(self, prefetchPartitions=False):
"""
Returns an iterator that contains all of the rows in this :class:`DataFrame`.
The iterator will consume as much memory as the largest partition in this
:class:`DataFrame`. With prefetch it may consume up to the memory of the 2 largest
partitions.
:param prefetchPartitions: If Spark should pre-fetch the next partition
before it is needed.
>>> list(df.toLocalIterator())
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
"""
with SCCallSiteSync(self._sc) as css:
sock_info = self._jdf.toPythonIterator(prefetchPartitions)
return _local_iterator_from_socket(sock_info, BatchedSerializer(PickleSerializer()))
@ignore_unicode_prefix
@since(1.3)
def limit(self, num):
"""Limits the result count to the number specified.
>>> df.limit(1).collect()
[Row(age=2, name=u'Alice')]
>>> df.limit(0).collect()
[]
"""
jdf = self._jdf.limit(num)
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def take(self, num):
"""Returns the first ``num`` rows as a :class:`list` of :class:`Row`.
>>> df.take(2)
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
"""
return self.limit(num).collect()
@ignore_unicode_prefix
@since(3.0)
def tail(self, num):
"""
Returns the last ``num`` rows as a :class:`list` of :class:`Row`.
Running tail requires moving data into the application's driver process, and doing so with
a very large ``num`` can crash the driver process with OutOfMemoryError.
>>> df.tail(1)
[Row(age=5, name=u'Bob')]
"""
with SCCallSiteSync(self._sc):
sock_info = self._jdf.tailToPython(num)
return list(_load_from_socket(sock_info, BatchedSerializer(PickleSerializer())))
@since(1.3)
def foreach(self, f):
"""Applies the ``f`` function to all :class:`Row` of this :class:`DataFrame`.
This is a shorthand for ``df.rdd.foreach()``.
>>> def f(person):
... print(person.name)
>>> df.foreach(f)
"""
self.rdd.foreach(f)
@since(1.3)
def foreachPartition(self, f):
"""Applies the ``f`` function to each partition of this :class:`DataFrame`.
This a shorthand for ``df.rdd.foreachPartition()``.
>>> def f(people):
... for person in people:
... print(person.name)
>>> df.foreachPartition(f)
"""
self.rdd.foreachPartition(f)
@since(1.3)
def cache(self):
"""Persists the :class:`DataFrame` with the default storage level (`MEMORY_AND_DISK`).
.. note:: The default storage level has changed to `MEMORY_AND_DISK` to match Scala in 2.0.
"""
self.is_cached = True
self._jdf.cache()
return self
@since(1.3)
def persist(self, storageLevel=StorageLevel.MEMORY_AND_DISK):
"""Sets the storage level to persist the contents of the :class:`DataFrame` across
operations after the first time it is computed. This can only be used to assign
a new storage level if the :class:`DataFrame` does not have a storage level set yet.
If no storage level is specified defaults to (`MEMORY_AND_DISK`).
.. note:: The default storage level has changed to `MEMORY_AND_DISK` to match Scala in 2.0.
"""
self.is_cached = True
javaStorageLevel = self._sc._getJavaStorageLevel(storageLevel)
self._jdf.persist(javaStorageLevel)
return self
@property
@since(2.1)
def storageLevel(self):
"""Get the :class:`DataFrame`'s current storage level.
>>> df.storageLevel
StorageLevel(False, False, False, False, 1)
>>> df.cache().storageLevel
StorageLevel(True, True, False, True, 1)
>>> df2.persist(StorageLevel.DISK_ONLY_2).storageLevel
StorageLevel(True, False, False, False, 2)
"""
java_storage_level = self._jdf.storageLevel()
storage_level = StorageLevel(java_storage_level.useDisk(),
java_storage_level.useMemory(),
java_storage_level.useOffHeap(),
java_storage_level.deserialized(),
java_storage_level.replication())
return storage_level
@since(1.3)
def unpersist(self, blocking=False):
"""Marks the :class:`DataFrame` as non-persistent, and remove all blocks for it from
memory and disk.
.. note:: `blocking` default has changed to ``False`` to match Scala in 2.0.
"""
self.is_cached = False
self._jdf.unpersist(blocking)
return self
@since(1.4)
def coalesce(self, numPartitions):
"""
Returns a new :class:`DataFrame` that has exactly `numPartitions` partitions.
:param numPartitions: int, to specify the target number of partitions
Similar to coalesce defined on an :class:`RDD`, this operation results in a
narrow dependency, e.g. if you go from 1000 partitions to 100 partitions,
there will not be a shuffle, instead each of the 100 new partitions will
claim 10 of the current partitions. If a larger number of partitions is requested,
it will stay at the current number of partitions.
However, if you're doing a drastic coalesce, e.g. to numPartitions = 1,
this may result in your computation taking place on fewer nodes than
you like (e.g. one node in the case of numPartitions = 1). To avoid this,
you can call repartition(). This will add a shuffle step, but means the
current upstream partitions will be executed in parallel (per whatever
the current partitioning is).
>>> df.coalesce(1).rdd.getNumPartitions()
1
"""
return DataFrame(self._jdf.coalesce(numPartitions), self.sql_ctx)
@since(1.3)
def repartition(self, numPartitions, *cols):
"""
Returns a new :class:`DataFrame` partitioned by the given partitioning expressions. The
resulting :class:`DataFrame` is hash partitioned.
:param numPartitions:
can be an int to specify the target number of partitions or a Column.
If it is a Column, it will be used as the first partitioning column. If not specified,
the default number of partitions is used.
.. versionchanged:: 1.6
Added optional arguments to specify the partitioning columns. Also made numPartitions
optional if partitioning columns are specified.
>>> df.repartition(10).rdd.getNumPartitions()
10
>>> data = df.union(df).repartition("age")
>>> data.show()
+---+-----+
|age| name|
+---+-----+
| 5| Bob|
| 5| Bob|
| 2|Alice|
| 2|Alice|
+---+-----+
>>> data = data.repartition(7, "age")
>>> data.show()
+---+-----+
|age| name|
+---+-----+
| 2|Alice|
| 5| Bob|
| 2|Alice|
| 5| Bob|
+---+-----+
>>> data.rdd.getNumPartitions()
7
>>> data = data.repartition("name", "age")
>>> data.show()
+---+-----+
|age| name|
+---+-----+
| 5| Bob|
| 5| Bob|
| 2|Alice|
| 2|Alice|
+---+-----+
"""
if isinstance(numPartitions, int):
if len(cols) == 0:
return DataFrame(self._jdf.repartition(numPartitions), self.sql_ctx)
else:
return DataFrame(
self._jdf.repartition(numPartitions, self._jcols(*cols)), self.sql_ctx)
elif isinstance(numPartitions, (basestring, Column)):
cols = (numPartitions, ) + cols
return DataFrame(self._jdf.repartition(self._jcols(*cols)), self.sql_ctx)
else:
raise TypeError("numPartitions should be an int or Column")
@since("2.4.0")
def repartitionByRange(self, numPartitions, *cols):
"""
Returns a new :class:`DataFrame` partitioned by the given partitioning expressions. The
resulting :class:`DataFrame` is range partitioned.
:param numPartitions:
can be an int to specify the target number of partitions or a Column.
If it is a Column, it will be used as the first partitioning column. If not specified,
the default number of partitions is used.
At least one partition-by expression must be specified.
When no explicit sort order is specified, "ascending nulls first" is assumed.
Note that due to performance reasons this method uses sampling to estimate the ranges.
Hence, the output may not be consistent, since sampling can return different values.
The sample size can be controlled by the config
`spark.sql.execution.rangeExchange.sampleSizePerPartition`.
>>> df.repartitionByRange(2, "age").rdd.getNumPartitions()
2
>>> df.show()
+---+-----+
|age| name|
+---+-----+
| 2|Alice|
| 5| Bob|
+---+-----+
>>> df.repartitionByRange(1, "age").rdd.getNumPartitions()
1
>>> data = df.repartitionByRange("age")
>>> df.show()
+---+-----+
|age| name|
+---+-----+
| 2|Alice|
| 5| Bob|
+---+-----+
"""
if isinstance(numPartitions, int):
if len(cols) == 0:
return ValueError("At least one partition-by expression must be specified.")
else:
return DataFrame(
self._jdf.repartitionByRange(numPartitions, self._jcols(*cols)), self.sql_ctx)
elif isinstance(numPartitions, (basestring, Column)):
cols = (numPartitions,) + cols
return DataFrame(self._jdf.repartitionByRange(self._jcols(*cols)), self.sql_ctx)
else:
raise TypeError("numPartitions should be an int, string or Column")
@since(1.3)
def distinct(self):
"""Returns a new :class:`DataFrame` containing the distinct rows in this :class:`DataFrame`.
>>> df.distinct().count()
2
"""
return DataFrame(self._jdf.distinct(), self.sql_ctx)
@since(1.3)
def sample(self, withReplacement=None, fraction=None, seed=None):
"""Returns a sampled subset of this :class:`DataFrame`.
:param withReplacement: Sample with replacement or not (default ``False``).
:param fraction: Fraction of rows to generate, range [0.0, 1.0].
:param seed: Seed for sampling (default a random seed).
.. note:: This is not guaranteed to provide exactly the fraction specified of the total
count of the given :class:`DataFrame`.
.. note:: `fraction` is required and, `withReplacement` and `seed` are optional.
>>> df = spark.range(10)
>>> df.sample(0.5, 3).count()
7
>>> df.sample(fraction=0.5, seed=3).count()
7
>>> df.sample(withReplacement=True, fraction=0.5, seed=3).count()
1
>>> df.sample(1.0).count()
10
>>> df.sample(fraction=1.0).count()
10
>>> df.sample(False, fraction=1.0).count()
10
"""
# For the cases below:
# sample(True, 0.5 [, seed])
# sample(True, fraction=0.5 [, seed])
# sample(withReplacement=False, fraction=0.5 [, seed])
is_withReplacement_set = \
type(withReplacement) == bool and isinstance(fraction, float)
# For the case below:
# sample(faction=0.5 [, seed])
is_withReplacement_omitted_kwargs = \
withReplacement is None and isinstance(fraction, float)
# For the case below:
# sample(0.5 [, seed])
is_withReplacement_omitted_args = isinstance(withReplacement, float)
if not (is_withReplacement_set
or is_withReplacement_omitted_kwargs
or is_withReplacement_omitted_args):
argtypes = [
str(type(arg)) for arg in [withReplacement, fraction, seed] if arg is not None]
raise TypeError(
"withReplacement (optional), fraction (required) and seed (optional)"
" should be a bool, float and number; however, "
"got [%s]." % ", ".join(argtypes))
if is_withReplacement_omitted_args:
if fraction is not None:
seed = fraction
fraction = withReplacement
withReplacement = None
seed = long(seed) if seed is not None else None
args = [arg for arg in [withReplacement, fraction, seed] if arg is not None]
jdf = self._jdf.sample(*args)
return DataFrame(jdf, self.sql_ctx)
@since(1.5)
def sampleBy(self, col, fractions, seed=None):
"""
Returns a stratified sample without replacement based on the
fraction given on each stratum.
:param col: column that defines strata
:param fractions:
sampling fraction for each stratum. If a stratum is not
specified, we treat its fraction as zero.
:param seed: random seed
:return: a new :class:`DataFrame` that represents the stratified sample
>>> from pyspark.sql.functions import col
>>> dataset = sqlContext.range(0, 100).select((col("id") % 3).alias("key"))
>>> sampled = dataset.sampleBy("key", fractions={0: 0.1, 1: 0.2}, seed=0)
>>> sampled.groupBy("key").count().orderBy("key").show()
+---+-----+
|key|count|
+---+-----+
| 0| 3|
| 1| 6|
+---+-----+
>>> dataset.sampleBy(col("key"), fractions={2: 1.0}, seed=0).count()
33
.. versionchanged:: 3.0
Added sampling by a column of :class:`Column`
"""
if isinstance(col, basestring):
col = Column(col)
elif not isinstance(col, Column):
raise ValueError("col must be a string or a column, but got %r" % type(col))
if not isinstance(fractions, dict):
raise ValueError("fractions must be a dict but got %r" % type(fractions))
for k, v in fractions.items():
if not isinstance(k, (float, int, long, basestring)):
raise ValueError("key must be float, int, long, or string, but got %r" % type(k))
fractions[k] = float(v)
col = col._jc
seed = seed if seed is not None else random.randint(0, sys.maxsize)
return DataFrame(self._jdf.stat().sampleBy(col, self._jmap(fractions), seed), self.sql_ctx)
@since(1.4)
def randomSplit(self, weights, seed=None):
"""Randomly splits this :class:`DataFrame` with the provided weights.
:param weights: list of doubles as weights with which to split the :class:`DataFrame`.
Weights will be normalized if they don't sum up to 1.0.
:param seed: The seed for sampling.
>>> splits = df4.randomSplit([1.0, 2.0], 24)
>>> splits[0].count()
2
>>> splits[1].count()
2
"""
for w in weights:
if w < 0.0:
raise ValueError("Weights must be positive. Found weight value: %s" % w)
seed = seed if seed is not None else random.randint(0, sys.maxsize)
rdd_array = self._jdf.randomSplit(_to_list(self.sql_ctx._sc, weights), long(seed))
return [DataFrame(rdd, self.sql_ctx) for rdd in rdd_array]
@property
@since(1.3)
def dtypes(self):
"""Returns all column names and their data types as a list.
>>> df.dtypes
[('age', 'int'), ('name', 'string')]
"""
return [(str(f.name), f.dataType.simpleString()) for f in self.schema.fields]
@property
@since(1.3)
def columns(self):
"""Returns all column names as a list.
>>> df.columns
['age', 'name']
"""
return [f.name for f in self.schema.fields]
@since(2.3)
def colRegex(self, colName):
"""
Selects column based on the column name specified as a regex and returns it
as :class:`Column`.
:param colName: string, column name specified as a regex.
>>> df = spark.createDataFrame([("a", 1), ("b", 2), ("c", 3)], ["Col1", "Col2"])
>>> df.select(df.colRegex("`(Col1)?+.+`")).show()
+----+
|Col2|
+----+
| 1|
| 2|
| 3|
+----+
"""
if not isinstance(colName, basestring):
raise ValueError("colName should be provided as string")
jc = self._jdf.colRegex(colName)
return Column(jc)
@ignore_unicode_prefix
@since(1.3)
def alias(self, alias):
"""Returns a new :class:`DataFrame` with an alias set.
:param alias: string, an alias name to be set for the :class:`DataFrame`.
>>> from pyspark.sql.functions import *
>>> df_as1 = df.alias("df_as1")
>>> df_as2 = df.alias("df_as2")
>>> joined_df = df_as1.join(df_as2, col("df_as1.name") == col("df_as2.name"), 'inner')
>>> joined_df.select("df_as1.name", "df_as2.name", "df_as2.age") \
.sort(desc("df_as1.name")).collect()
[Row(name=u'Bob', name=u'Bob', age=5), Row(name=u'Alice', name=u'Alice', age=2)]
"""
assert isinstance(alias, basestring), "alias should be a string"
return DataFrame(getattr(self._jdf, "as")(alias), self.sql_ctx)
@ignore_unicode_prefix
@since(2.1)
def crossJoin(self, other):
"""Returns the cartesian product with another :class:`DataFrame`.
:param other: Right side of the cartesian product.
>>> df.select("age", "name").collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
>>> df2.select("name", "height").collect()
[Row(name=u'Tom', height=80), Row(name=u'Bob', height=85)]
>>> df.crossJoin(df2.select("height")).select("age", "name", "height").collect()
[Row(age=2, name=u'Alice', height=80), Row(age=2, name=u'Alice', height=85),
Row(age=5, name=u'Bob', height=80), Row(age=5, name=u'Bob', height=85)]
"""
jdf = self._jdf.crossJoin(other._jdf)
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def join(self, other, on=None, how=None):
"""Joins with another :class:`DataFrame`, using the given join expression.
:param other: Right side of the join
:param on: a string for the join column name, a list of column names,
a join expression (Column), or a list of Columns.
If `on` is a string or a list of strings indicating the name of the join column(s),
the column(s) must exist on both sides, and this performs an equi-join.
:param how: str, default ``inner``. Must be one of: ``inner``, ``cross``, ``outer``,
``full``, ``fullouter``, ``full_outer``, ``left``, ``leftouter``, ``left_outer``,
``right``, ``rightouter``, ``right_outer``, ``semi``, ``leftsemi``, ``left_semi``,
``anti``, ``leftanti`` and ``left_anti``.
The following performs a full outer join between ``df1`` and ``df2``.
>>> from pyspark.sql.functions import desc
>>> df.join(df2, df.name == df2.name, 'outer').select(df.name, df2.height) \
.sort(desc("name")).collect()
[Row(name=u'Bob', height=85), Row(name=u'Alice', height=None), Row(name=None, height=80)]
>>> df.join(df2, 'name', 'outer').select('name', 'height').sort(desc("name")).collect()
[Row(name=u'Tom', height=80), Row(name=u'Bob', height=85), Row(name=u'Alice', height=None)]
>>> cond = [df.name == df3.name, df.age == df3.age]
>>> df.join(df3, cond, 'outer').select(df.name, df3.age).collect()
[Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
>>> df.join(df2, 'name').select(df.name, df2.height).collect()
[Row(name=u'Bob', height=85)]
>>> df.join(df4, ['name', 'age']).select(df.name, df.age).collect()
[Row(name=u'Bob', age=5)]
"""
if on is not None and not isinstance(on, list):
on = [on]
if on is not None:
if isinstance(on[0], basestring):
on = self._jseq(on)
else:
assert isinstance(on[0], Column), "on should be Column or list of Column"
on = reduce(lambda x, y: x.__and__(y), on)
on = on._jc
if on is None and how is None:
jdf = self._jdf.join(other._jdf)
else:
if how is None:
how = "inner"
if on is None:
on = self._jseq([])
assert isinstance(how, basestring), "how should be basestring"
jdf = self._jdf.join(other._jdf, on, how)
return DataFrame(jdf, self.sql_ctx)
@since(1.6)
def sortWithinPartitions(self, *cols, **kwargs):
"""Returns a new :class:`DataFrame` with each partition sorted by the specified column(s).
:param cols: list of :class:`Column` or column names to sort by.
:param ascending: boolean or list of boolean (default ``True``).
Sort ascending vs. descending. Specify list for multiple sort orders.
If a list is specified, length of the list must equal length of the `cols`.
>>> df.sortWithinPartitions("age", ascending=False).show()
+---+-----+
|age| name|
+---+-----+
| 2|Alice|
| 5| Bob|
+---+-----+
"""
jdf = self._jdf.sortWithinPartitions(self._sort_cols(cols, kwargs))
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def sort(self, *cols, **kwargs):
"""Returns a new :class:`DataFrame` sorted by the specified column(s).
:param cols: list of :class:`Column` or column names to sort by.
:param ascending: boolean or list of boolean (default ``True``).
Sort ascending vs. descending. Specify list for multiple sort orders.
If a list is specified, length of the list must equal length of the `cols`.
>>> df.sort(df.age.desc()).collect()
[Row(age=5, name=u'Bob'), Row(age=2, name=u'Alice')]
>>> df.sort("age", ascending=False).collect()
[Row(age=5, name=u'Bob'), Row(age=2, name=u'Alice')]
>>> df.orderBy(df.age.desc()).collect()
[Row(age=5, name=u'Bob'), Row(age=2, name=u'Alice')]
>>> from pyspark.sql.functions import *
>>> df.sort(asc("age")).collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
>>> df.orderBy(desc("age"), "name").collect()
[Row(age=5, name=u'Bob'), Row(age=2, name=u'Alice')]
>>> df.orderBy(["age", "name"], ascending=[0, 1]).collect()
[Row(age=5, name=u'Bob'), Row(age=2, name=u'Alice')]
"""
jdf = self._jdf.sort(self._sort_cols(cols, kwargs))
return DataFrame(jdf, self.sql_ctx)
orderBy = sort
def _jseq(self, cols, converter=None):
"""Return a JVM Seq of Columns from a list of Column or names"""
return _to_seq(self.sql_ctx._sc, cols, converter)
def _jmap(self, jm):
"""Return a JVM Scala Map from a dict"""
return _to_scala_map(self.sql_ctx._sc, jm)
def _jcols(self, *cols):
"""Return a JVM Seq of Columns from a list of Column or column names
If `cols` has only one list in it, cols[0] will be used as the list.
"""
if len(cols) == 1 and isinstance(cols[0], list):
cols = cols[0]
return self._jseq(cols, _to_java_column)
def _sort_cols(self, cols, kwargs):
""" Return a JVM Seq of Columns that describes the sort order
"""
if not cols:
raise ValueError("should sort by at least one column")
if len(cols) == 1 and isinstance(cols[0], list):
cols = cols[0]
jcols = [_to_java_column(c) for c in cols]
ascending = kwargs.get('ascending', True)
if isinstance(ascending, (bool, int)):
if not ascending:
jcols = [jc.desc() for jc in jcols]
elif isinstance(ascending, list):
jcols = [jc if asc else jc.desc()
for asc, jc in zip(ascending, jcols)]
else:
raise TypeError("ascending can only be boolean or list, but got %s" % type(ascending))
return self._jseq(jcols)
@since("1.3.1")
def describe(self, *cols):
"""Computes basic statistics for numeric and string columns.
This include count, mean, stddev, min, and max. If no columns are
given, this function computes statistics for all numerical or string columns.
.. note:: This function is meant for exploratory data analysis, as we make no
guarantee about the backward compatibility of the schema of the resulting
:class:`DataFrame`.
>>> df.describe(['age']).show()
+-------+------------------+
|summary| age|
+-------+------------------+
| count| 2|
| mean| 3.5|
| stddev|2.1213203435596424|
| min| 2|
| max| 5|
+-------+------------------+
>>> df.describe().show()
+-------+------------------+-----+
|summary| age| name|
+-------+------------------+-----+
| count| 2| 2|
| mean| 3.5| null|
| stddev|2.1213203435596424| null|
| min| 2|Alice|
| max| 5| Bob|
+-------+------------------+-----+
Use summary for expanded statistics and control over which statistics to compute.
"""
if len(cols) == 1 and isinstance(cols[0], list):
cols = cols[0]
jdf = self._jdf.describe(self._jseq(cols))
return DataFrame(jdf, self.sql_ctx)
@since("2.3.0")
def summary(self, *statistics):
"""Computes specified statistics for numeric and string columns. Available statistics are:
- count
- mean
- stddev
- min
- max
- arbitrary approximate percentiles specified as a percentage (eg, 75%)
If no statistics are given, this function computes count, mean, stddev, min,
approximate quartiles (percentiles at 25%, 50%, and 75%), and max.
.. note:: This function is meant for exploratory data analysis, as we make no
guarantee about the backward compatibility of the schema of the resulting
:class:`DataFrame`.
>>> df.summary().show()
+-------+------------------+-----+
|summary| age| name|
+-------+------------------+-----+
| count| 2| 2|
| mean| 3.5| null|
| stddev|2.1213203435596424| null|
| min| 2|Alice|
| 25%| 2| null|
| 50%| 2| null|
| 75%| 5| null|
| max| 5| Bob|
+-------+------------------+-----+
>>> df.summary("count", "min", "25%", "75%", "max").show()
+-------+---+-----+
|summary|age| name|
+-------+---+-----+
| count| 2| 2|
| min| 2|Alice|
| 25%| 2| null|
| 75%| 5| null|
| max| 5| Bob|
+-------+---+-----+
To do a summary for specific columns first select them:
>>> df.select("age", "name").summary("count").show()
+-------+---+----+
|summary|age|name|
+-------+---+----+
| count| 2| 2|
+-------+---+----+
See also describe for basic statistics.
"""
if len(statistics) == 1 and isinstance(statistics[0], list):
statistics = statistics[0]
jdf = self._jdf.summary(self._jseq(statistics))
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def head(self, n=None):
"""Returns the first ``n`` rows.
.. note:: This method should only be used if the resulting array is expected
to be small, as all the data is loaded into the driver's memory.
:param n: int, default 1. Number of rows to return.
:return: If n is greater than 1, return a list of :class:`Row`.
If n is 1, return a single Row.
>>> df.head()
Row(age=2, name=u'Alice')
>>> df.head(1)
[Row(age=2, name=u'Alice')]
"""
if n is None:
rs = self.head(1)
return rs[0] if rs else None
return self.take(n)
@ignore_unicode_prefix
@since(1.3)
def first(self):
"""Returns the first row as a :class:`Row`.
>>> df.first()
Row(age=2, name=u'Alice')
"""
return self.head()
@ignore_unicode_prefix
@since(1.3)
def __getitem__(self, item):
"""Returns the column as a :class:`Column`.
>>> df.select(df['age']).collect()
[Row(age=2), Row(age=5)]
>>> df[ ["name", "age"]].collect()
[Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
>>> df[ df.age > 3 ].collect()
[Row(age=5, name=u'Bob')]
>>> df[df[0] > 3].collect()
[Row(age=5, name=u'Bob')]
"""
if isinstance(item, basestring):
jc = self._jdf.apply(item)
return Column(jc)
elif isinstance(item, Column):
return self.filter(item)
elif isinstance(item, (list, tuple)):
return self.select(*item)
elif isinstance(item, int):
jc = self._jdf.apply(self.columns[item])
return Column(jc)
else:
raise TypeError("unexpected item type: %s" % type(item))
@since(1.3)
def __getattr__(self, name):
"""Returns the :class:`Column` denoted by ``name``.
>>> df.select(df.age).collect()
[Row(age=2), Row(age=5)]
"""
if name not in self.columns:
raise AttributeError(
"'%s' object has no attribute '%s'" % (self.__class__.__name__, name))
jc = self._jdf.apply(name)
return Column(jc)
@ignore_unicode_prefix
@since(1.3)
def select(self, *cols):
"""Projects a set of expressions and returns a new :class:`DataFrame`.
:param cols: list of column names (string) or expressions (:class:`Column`).
If one of the column names is '*', that column is expanded to include all columns
in the current :class:`DataFrame`.
>>> df.select('*').collect()
[Row(age=2, name=u'Alice'), Row(age=5, name=u'Bob')]
>>> df.select('name', 'age').collect()
[Row(name=u'Alice', age=2), Row(name=u'Bob', age=5)]
>>> df.select(df.name, (df.age + 10).alias('age')).collect()
[Row(name=u'Alice', age=12), Row(name=u'Bob', age=15)]
"""
jdf = self._jdf.select(self._jcols(*cols))
return DataFrame(jdf, self.sql_ctx)
@since(1.3)
def selectExpr(self, *expr):
"""Projects a set of SQL expressions and returns a new :class:`DataFrame`.
This is a variant of :func:`select` that accepts SQL expressions.
>>> df.selectExpr("age * 2", "abs(age)").collect()
[Row((age * 2)=4, abs(age)=2), Row((age * 2)=10, abs(age)=5)]
"""
if len(expr) == 1 and isinstance(expr[0], list):
expr = expr[0]
jdf = self._jdf.selectExpr(self._jseq(expr))
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def filter(self, condition):
"""Filters rows using the given condition.
:func:`where` is an alias for :func:`filter`.
:param condition: a :class:`Column` of :class:`types.BooleanType`
or a string of SQL expression.
>>> df.filter(df.age > 3).collect()
[Row(age=5, name=u'Bob')]
>>> df.where(df.age == 2).collect()
[Row(age=2, name=u'Alice')]
>>> df.filter("age > 3").collect()
[Row(age=5, name=u'Bob')]
>>> df.where("age = 2").collect()
[Row(age=2, name=u'Alice')]
"""
if isinstance(condition, basestring):
jdf = self._jdf.filter(condition)
elif isinstance(condition, Column):
jdf = self._jdf.filter(condition._jc)
else:
raise TypeError("condition should be string or Column")
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def groupBy(self, *cols):
"""Groups the :class:`DataFrame` using the specified columns,
so we can run aggregation on them. See :class:`GroupedData`
for all the available aggregate functions.
:func:`groupby` is an alias for :func:`groupBy`.
:param cols: list of columns to group by.
Each element should be a column name (string) or an expression (:class:`Column`).
>>> df.groupBy().avg().collect()
[Row(avg(age)=3.5)]
>>> sorted(df.groupBy('name').agg({'age': 'mean'}).collect())
[Row(name=u'Alice', avg(age)=2.0), Row(name=u'Bob', avg(age)=5.0)]
>>> sorted(df.groupBy(df.name).avg().collect())
[Row(name=u'Alice', avg(age)=2.0), Row(name=u'Bob', avg(age)=5.0)]
>>> sorted(df.groupBy(['name', df.age]).count().collect())
[Row(name=u'Alice', age=2, count=1), Row(name=u'Bob', age=5, count=1)]
"""
jgd = self._jdf.groupBy(self._jcols(*cols))
from pyspark.sql.group import GroupedData
return GroupedData(jgd, self)
@since(1.4)
def rollup(self, *cols):
"""
Create a multi-dimensional rollup for the current :class:`DataFrame` using
the specified columns, so we can run aggregation on them.
>>> df.rollup("name", df.age).count().orderBy("name", "age").show()
+-----+----+-----+
| name| age|count|
+-----+----+-----+
| null|null| 2|
|Alice|null| 1|
|Alice| 2| 1|
| Bob|null| 1|
| Bob| 5| 1|
+-----+----+-----+
"""
jgd = self._jdf.rollup(self._jcols(*cols))
from pyspark.sql.group import GroupedData
return GroupedData(jgd, self)
@since(1.4)
def cube(self, *cols):
"""
Create a multi-dimensional cube for the current :class:`DataFrame` using
the specified columns, so we can run aggregations on them.
>>> df.cube("name", df.age).count().orderBy("name", "age").show()
+-----+----+-----+
| name| age|count|
+-----+----+-----+
| null|null| 2|
| null| 2| 1|
| null| 5| 1|
|Alice|null| 1|
|Alice| 2| 1|
| Bob|null| 1|
| Bob| 5| 1|
+-----+----+-----+
"""
jgd = self._jdf.cube(self._jcols(*cols))
from pyspark.sql.group import GroupedData
return GroupedData(jgd, self)
@since(1.3)
def agg(self, *exprs):
""" Aggregate on the entire :class:`DataFrame` without groups
(shorthand for ``df.groupBy.agg()``).
>>> df.agg({"age": "max"}).collect()
[Row(max(age)=5)]
>>> from pyspark.sql import functions as F
>>> df.agg(F.min(df.age)).collect()
[Row(min(age)=2)]
"""
return self.groupBy().agg(*exprs)
@since(2.0)
def union(self, other):
""" Return a new :class:`DataFrame` containing union of rows in this and another
:class:`DataFrame`.
This is equivalent to `UNION ALL` in SQL. To do a SQL-style set union
(that does deduplication of elements), use this function followed by :func:`distinct`.
Also as standard in SQL, this function resolves columns by position (not by name).
"""
return DataFrame(self._jdf.union(other._jdf), self.sql_ctx)
@since(1.3)
def unionAll(self, other):
""" Return a new :class:`DataFrame` containing union of rows in this and another
:class:`DataFrame`.
This is equivalent to `UNION ALL` in SQL. To do a SQL-style set union
(that does deduplication of elements), use this function followed by :func:`distinct`.
Also as standard in SQL, this function resolves columns by position (not by name).
"""
return self.union(other)
@since(2.3)
def unionByName(self, other):
""" Returns a new :class:`DataFrame` containing union of rows in this and another
:class:`DataFrame`.
This is different from both `UNION ALL` and `UNION DISTINCT` in SQL. To do a SQL-style set
union (that does deduplication of elements), use this function followed by :func:`distinct`.
The difference between this function and :func:`union` is that this function
resolves columns by name (not by position):
>>> df1 = spark.createDataFrame([[1, 2, 3]], ["col0", "col1", "col2"])
>>> df2 = spark.createDataFrame([[4, 5, 6]], ["col1", "col2", "col0"])
>>> df1.unionByName(df2).show()
+----+----+----+
|col0|col1|col2|
+----+----+----+
| 1| 2| 3|
| 6| 4| 5|
+----+----+----+
"""
return DataFrame(self._jdf.unionByName(other._jdf), self.sql_ctx)
@since(1.3)
def intersect(self, other):
""" Return a new :class:`DataFrame` containing rows only in
both this :class:`DataFrame` and another :class:`DataFrame`.
This is equivalent to `INTERSECT` in SQL.
"""
return DataFrame(self._jdf.intersect(other._jdf), self.sql_ctx)
@since(2.4)
def intersectAll(self, other):
""" Return a new :class:`DataFrame` containing rows in both this :class:`DataFrame`
and another :class:`DataFrame` while preserving duplicates.
This is equivalent to `INTERSECT ALL` in SQL.
>>> df1 = spark.createDataFrame([("a", 1), ("a", 1), ("b", 3), ("c", 4)], ["C1", "C2"])
>>> df2 = spark.createDataFrame([("a", 1), ("a", 1), ("b", 3)], ["C1", "C2"])
>>> df1.intersectAll(df2).sort("C1", "C2").show()
+---+---+
| C1| C2|
+---+---+
| a| 1|
| a| 1|
| b| 3|
+---+---+
Also as standard in SQL, this function resolves columns by position (not by name).
"""
return DataFrame(self._jdf.intersectAll(other._jdf), self.sql_ctx)
@since(1.3)
def subtract(self, other):
""" Return a new :class:`DataFrame` containing rows in this :class:`DataFrame`
but not in another :class:`DataFrame`.
This is equivalent to `EXCEPT DISTINCT` in SQL.
"""
return DataFrame(getattr(self._jdf, "except")(other._jdf), self.sql_ctx)
@since(1.4)
def dropDuplicates(self, subset=None):
"""Return a new :class:`DataFrame` with duplicate rows removed,
optionally only considering certain columns.
For a static batch :class:`DataFrame`, it just drops duplicate rows. For a streaming
:class:`DataFrame`, it will keep all data across triggers as intermediate state to drop
duplicates rows. You can use :func:`withWatermark` to limit how late the duplicate data can
be and system will accordingly limit the state. In addition, too late data older than
watermark will be dropped to avoid any possibility of duplicates.
:func:`drop_duplicates` is an alias for :func:`dropDuplicates`.
>>> from pyspark.sql import Row
>>> df = sc.parallelize([ \\
... Row(name='Alice', age=5, height=80), \\
... Row(name='Alice', age=5, height=80), \\
... Row(name='Alice', age=10, height=80)]).toDF()
>>> df.dropDuplicates().show()
+---+------+-----+
|age|height| name|
+---+------+-----+
| 5| 80|Alice|
| 10| 80|Alice|
+---+------+-----+
>>> df.dropDuplicates(['name', 'height']).show()
+---+------+-----+
|age|height| name|
+---+------+-----+
| 5| 80|Alice|
+---+------+-----+
"""
if subset is None:
jdf = self._jdf.dropDuplicates()
else:
jdf = self._jdf.dropDuplicates(self._jseq(subset))
return DataFrame(jdf, self.sql_ctx)
@since("1.3.1")
def dropna(self, how='any', thresh=None, subset=None):
"""Returns a new :class:`DataFrame` omitting rows with null values.
:func:`DataFrame.dropna` and :func:`DataFrameNaFunctions.drop` are aliases of each other.
:param how: 'any' or 'all'.
If 'any', drop a row if it contains any nulls.
If 'all', drop a row only if all its values are null.
:param thresh: int, default None
If specified, drop rows that have less than `thresh` non-null values.
This overwrites the `how` parameter.
:param subset: optional list of column names to consider.
>>> df4.na.drop().show()
+---+------+-----+
|age|height| name|
+---+------+-----+
| 10| 80|Alice|
+---+------+-----+
"""
if how is not None and how not in ['any', 'all']:
raise ValueError("how ('" + how + "') should be 'any' or 'all'")
if subset is None:
subset = self.columns
elif isinstance(subset, basestring):
subset = [subset]
elif not isinstance(subset, (list, tuple)):
raise ValueError("subset should be a list or tuple of column names")
if thresh is None:
thresh = len(subset) if how == 'any' else 1
return DataFrame(self._jdf.na().drop(thresh, self._jseq(subset)), self.sql_ctx)
@since("1.3.1")
def fillna(self, value, subset=None):
"""Replace null values, alias for ``na.fill()``.
:func:`DataFrame.fillna` and :func:`DataFrameNaFunctions.fill` are aliases of each other.
:param value: int, long, float, string, bool or dict.
Value to replace null values with.
If the value is a dict, then `subset` is ignored and `value` must be a mapping
from column name (string) to replacement value. The replacement value must be
an int, long, float, boolean, or string.
:param subset: optional list of column names to consider.
Columns specified in subset that do not have matching data type are ignored.
For example, if `value` is a string, and subset contains a non-string column,
then the non-string column is simply ignored.
>>> df4.na.fill(50).show()
+---+------+-----+
|age|height| name|
+---+------+-----+
| 10| 80|Alice|
| 5| 50| Bob|
| 50| 50| Tom|
| 50| 50| null|
+---+------+-----+
>>> df5.na.fill(False).show()
+----+-------+-----+
| age| name| spy|
+----+-------+-----+
| 10| Alice|false|
| 5| Bob|false|
|null|Mallory| true|
+----+-------+-----+
>>> df4.na.fill({'age': 50, 'name': 'unknown'}).show()
+---+------+-------+
|age|height| name|
+---+------+-------+
| 10| 80| Alice|
| 5| null| Bob|
| 50| null| Tom|
| 50| null|unknown|
+---+------+-------+
"""
if not isinstance(value, (float, int, long, basestring, bool, dict)):
raise ValueError("value should be a float, int, long, string, bool or dict")
# Note that bool validates isinstance(int), but we don't want to
# convert bools to floats
if not isinstance(value, bool) and isinstance(value, (int, long)):
value = float(value)
if isinstance(value, dict):
return DataFrame(self._jdf.na().fill(value), self.sql_ctx)
elif subset is None:
return DataFrame(self._jdf.na().fill(value), self.sql_ctx)
else:
if isinstance(subset, basestring):
subset = [subset]
elif not isinstance(subset, (list, tuple)):
raise ValueError("subset should be a list or tuple of column names")
return DataFrame(self._jdf.na().fill(value, self._jseq(subset)), self.sql_ctx)
@since(1.4)
def replace(self, to_replace, value=_NoValue, subset=None):
"""Returns a new :class:`DataFrame` replacing a value with another value.
:func:`DataFrame.replace` and :func:`DataFrameNaFunctions.replace` are
aliases of each other.
Values to_replace and value must have the same type and can only be numerics, booleans,
or strings. Value can have None. When replacing, the new value will be cast
to the type of the existing column.
For numeric replacements all values to be replaced should have unique
floating point representation. In case of conflicts (for example with `{42: -1, 42.0: 1}`)
and arbitrary replacement will be used.
:param to_replace: bool, int, long, float, string, list or dict.
Value to be replaced.
If the value is a dict, then `value` is ignored or can be omitted, and `to_replace`
must be a mapping between a value and a replacement.
:param value: bool, int, long, float, string, list or None.
The replacement value must be a bool, int, long, float, string or None. If `value` is a
list, `value` should be of the same length and type as `to_replace`.
If `value` is a scalar and `to_replace` is a sequence, then `value` is
used as a replacement for each item in `to_replace`.
:param subset: optional list of column names to consider.
Columns specified in subset that do not have matching data type are ignored.
For example, if `value` is a string, and subset contains a non-string column,
then the non-string column is simply ignored.
>>> df4.na.replace(10, 20).show()
+----+------+-----+
| age|height| name|
+----+------+-----+
| 20| 80|Alice|
| 5| null| Bob|
|null| null| Tom|
|null| null| null|
+----+------+-----+
>>> df4.na.replace('Alice', None).show()
+----+------+----+
| age|height|name|
+----+------+----+
| 10| 80|null|
| 5| null| Bob|
|null| null| Tom|
|null| null|null|
+----+------+----+
>>> df4.na.replace({'Alice': None}).show()
+----+------+----+
| age|height|name|
+----+------+----+
| 10| 80|null|
| 5| null| Bob|
|null| null| Tom|
|null| null|null|
+----+------+----+
>>> df4.na.replace(['Alice', 'Bob'], ['A', 'B'], 'name').show()
+----+------+----+
| age|height|name|
+----+------+----+
| 10| 80| A|
| 5| null| B|
|null| null| Tom|
|null| null|null|
+----+------+----+
"""
if value is _NoValue:
if isinstance(to_replace, dict):
value = None
else:
raise TypeError("value argument is required when to_replace is not a dictionary.")
# Helper functions
def all_of(types):
"""Given a type or tuple of types and a sequence of xs
check if each x is instance of type(s)
>>> all_of(bool)([True, False])
True
>>> all_of(basestring)(["a", 1])
False
"""
def all_of_(xs):
return all(isinstance(x, types) for x in xs)
return all_of_
all_of_bool = all_of(bool)
all_of_str = all_of(basestring)
all_of_numeric = all_of((float, int, long))
# Validate input types
valid_types = (bool, float, int, long, basestring, list, tuple)
if not isinstance(to_replace, valid_types + (dict, )):
raise ValueError(
"to_replace should be a bool, float, int, long, string, list, tuple, or dict. "
"Got {0}".format(type(to_replace)))
if not isinstance(value, valid_types) and value is not None \
and not isinstance(to_replace, dict):
raise ValueError("If to_replace is not a dict, value should be "
"a bool, float, int, long, string, list, tuple or None. "
"Got {0}".format(type(value)))
if isinstance(to_replace, (list, tuple)) and isinstance(value, (list, tuple)):
if len(to_replace) != len(value):
raise ValueError("to_replace and value lists should be of the same length. "
"Got {0} and {1}".format(len(to_replace), len(value)))
if not (subset is None or isinstance(subset, (list, tuple, basestring))):
raise ValueError("subset should be a list or tuple of column names, "
"column name or None. Got {0}".format(type(subset)))
# Reshape input arguments if necessary
if isinstance(to_replace, (float, int, long, basestring)):
to_replace = [to_replace]
if isinstance(to_replace, dict):
rep_dict = to_replace
if value is not None:
warnings.warn("to_replace is a dict and value is not None. value will be ignored.")
else:
if isinstance(value, (float, int, long, basestring)) or value is None:
value = [value for _ in range(len(to_replace))]
rep_dict = dict(zip(to_replace, value))
if isinstance(subset, basestring):
subset = [subset]
# Verify we were not passed in mixed type generics.
if not any(all_of_type(rep_dict.keys())
and all_of_type(x for x in rep_dict.values() if x is not None)
for all_of_type in [all_of_bool, all_of_str, all_of_numeric]):
raise ValueError("Mixed type replacements are not supported")
if subset is None:
return DataFrame(self._jdf.na().replace('*', rep_dict), self.sql_ctx)
else:
return DataFrame(
self._jdf.na().replace(self._jseq(subset), self._jmap(rep_dict)), self.sql_ctx)
@since(2.0)
def approxQuantile(self, col, probabilities, relativeError):
"""
Calculates the approximate quantiles of numerical columns of a
:class:`DataFrame`.
The result of this algorithm has the following deterministic bound:
If the :class:`DataFrame` has N elements and if we request the quantile at
probability `p` up to error `err`, then the algorithm will return
a sample `x` from the :class:`DataFrame` so that the *exact* rank of `x` is
close to (p * N). More precisely,
floor((p - err) * N) <= rank(x) <= ceil((p + err) * N).
This method implements a variation of the Greenwald-Khanna
algorithm (with some speed optimizations). The algorithm was first
present in [[https://doi.org/10.1145/375663.375670
Space-efficient Online Computation of Quantile Summaries]]
by Greenwald and Khanna.
Note that null values will be ignored in numerical columns before calculation.
For columns only containing null values, an empty list is returned.
:param col: str, list.
Can be a single column name, or a list of names for multiple columns.
:param probabilities: a list of quantile probabilities
Each number must belong to [0, 1].
For example 0 is the minimum, 0.5 is the median, 1 is the maximum.
:param relativeError: The relative target precision to achieve
(>= 0). If set to zero, the exact quantiles are computed, which
could be very expensive. Note that values greater than 1 are
accepted but give the same result as 1.
:return: the approximate quantiles at the given probabilities. If
the input `col` is a string, the output is a list of floats. If the
input `col` is a list or tuple of strings, the output is also a
list, but each element in it is a list of floats, i.e., the output
is a list of list of floats.
.. versionchanged:: 2.2
Added support for multiple columns.
"""
if not isinstance(col, (basestring, list, tuple)):
raise ValueError("col should be a string, list or tuple, but got %r" % type(col))
isStr = isinstance(col, basestring)
if isinstance(col, tuple):
col = list(col)
elif isStr:
col = [col]
for c in col:
if not isinstance(c, basestring):
raise ValueError("columns should be strings, but got %r" % type(c))
col = _to_list(self._sc, col)
if not isinstance(probabilities, (list, tuple)):
raise ValueError("probabilities should be a list or tuple")
if isinstance(probabilities, tuple):
probabilities = list(probabilities)
for p in probabilities:
if not isinstance(p, (float, int, long)) or p < 0 or p > 1:
raise ValueError("probabilities should be numerical (float, int, long) in [0,1].")
probabilities = _to_list(self._sc, probabilities)
if not isinstance(relativeError, (float, int, long)) or relativeError < 0:
raise ValueError("relativeError should be numerical (float, int, long) >= 0.")
relativeError = float(relativeError)
jaq = self._jdf.stat().approxQuantile(col, probabilities, relativeError)
jaq_list = [list(j) for j in jaq]
return jaq_list[0] if isStr else jaq_list
@since(1.4)
def corr(self, col1, col2, method=None):
"""
Calculates the correlation of two columns of a :class:`DataFrame` as a double value.
Currently only supports the Pearson Correlation Coefficient.
:func:`DataFrame.corr` and :func:`DataFrameStatFunctions.corr` are aliases of each other.
:param col1: The name of the first column
:param col2: The name of the second column
:param method: The correlation method. Currently only supports "pearson"
"""
if not isinstance(col1, basestring):
raise ValueError("col1 should be a string.")
if not isinstance(col2, basestring):
raise ValueError("col2 should be a string.")
if not method:
method = "pearson"
if not method == "pearson":
raise ValueError("Currently only the calculation of the Pearson Correlation " +
"coefficient is supported.")
return self._jdf.stat().corr(col1, col2, method)
@since(1.4)
def cov(self, col1, col2):
"""
Calculate the sample covariance for the given columns, specified by their names, as a
double value. :func:`DataFrame.cov` and :func:`DataFrameStatFunctions.cov` are aliases.
:param col1: The name of the first column
:param col2: The name of the second column
"""
if not isinstance(col1, basestring):
raise ValueError("col1 should be a string.")
if not isinstance(col2, basestring):
raise ValueError("col2 should be a string.")
return self._jdf.stat().cov(col1, col2)
@since(1.4)
def crosstab(self, col1, col2):
"""
Computes a pair-wise frequency table of the given columns. Also known as a contingency
table. The number of distinct values for each column should be less than 1e4. At most 1e6
non-zero pair frequencies will be returned.
The first column of each row will be the distinct values of `col1` and the column names
will be the distinct values of `col2`. The name of the first column will be `$col1_$col2`.
Pairs that have no occurrences will have zero as their counts.
:func:`DataFrame.crosstab` and :func:`DataFrameStatFunctions.crosstab` are aliases.
:param col1: The name of the first column. Distinct items will make the first item of
each row.
:param col2: The name of the second column. Distinct items will make the column names
of the :class:`DataFrame`.
"""
if not isinstance(col1, basestring):
raise ValueError("col1 should be a string.")
if not isinstance(col2, basestring):
raise ValueError("col2 should be a string.")
return DataFrame(self._jdf.stat().crosstab(col1, col2), self.sql_ctx)
@since(1.4)
def freqItems(self, cols, support=None):
"""
Finding frequent items for columns, possibly with false positives. Using the
frequent element count algorithm described in
"https://doi.org/10.1145/762471.762473, proposed by Karp, Schenker, and Papadimitriou".
:func:`DataFrame.freqItems` and :func:`DataFrameStatFunctions.freqItems` are aliases.
.. note:: This function is meant for exploratory data analysis, as we make no
guarantee about the backward compatibility of the schema of the resulting
:class:`DataFrame`.
:param cols: Names of the columns to calculate frequent items for as a list or tuple of
strings.
:param support: The frequency with which to consider an item 'frequent'. Default is 1%.
The support must be greater than 1e-4.
"""
if isinstance(cols, tuple):
cols = list(cols)
if not isinstance(cols, list):
raise ValueError("cols must be a list or tuple of column names as strings.")
if not support:
support = 0.01
return DataFrame(self._jdf.stat().freqItems(_to_seq(self._sc, cols), support), self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def withColumn(self, colName, col):
"""
Returns a new :class:`DataFrame` by adding a column or replacing the
existing column that has the same name.
The column expression must be an expression over this :class:`DataFrame`; attempting to add
a column from some other :class:`DataFrame` will raise an error.
:param colName: string, name of the new column.
:param col: a :class:`Column` expression for the new column.
.. note:: This method introduces a projection internally. Therefore, calling it multiple
times, for instance, via loops in order to add multiple columns can generate big
plans which can cause performance issues and even `StackOverflowException`.
To avoid this, use :func:`select` with the multiple columns at once.
>>> df.withColumn('age2', df.age + 2).collect()
[Row(age=2, name=u'Alice', age2=4), Row(age=5, name=u'Bob', age2=7)]
"""
assert isinstance(col, Column), "col should be Column"
return DataFrame(self._jdf.withColumn(colName, col._jc), self.sql_ctx)
@ignore_unicode_prefix
@since(1.3)
def withColumnRenamed(self, existing, new):
"""Returns a new :class:`DataFrame` by renaming an existing column.
This is a no-op if schema doesn't contain the given column name.
:param existing: string, name of the existing column to rename.
:param new: string, new name of the column.
>>> df.withColumnRenamed('age', 'age2').collect()
[Row(age2=2, name=u'Alice'), Row(age2=5, name=u'Bob')]
"""
return DataFrame(self._jdf.withColumnRenamed(existing, new), self.sql_ctx)
@since(1.4)
@ignore_unicode_prefix
def drop(self, *cols):
"""Returns a new :class:`DataFrame` that drops the specified column.
This is a no-op if schema doesn't contain the given column name(s).
:param cols: a string name of the column to drop, or a
:class:`Column` to drop, or a list of string name of the columns to drop.
>>> df.drop('age').collect()
[Row(name=u'Alice'), Row(name=u'Bob')]
>>> df.drop(df.age).collect()
[Row(name=u'Alice'), Row(name=u'Bob')]
>>> df.join(df2, df.name == df2.name, 'inner').drop(df.name).collect()
[Row(age=5, height=85, name=u'Bob')]
>>> df.join(df2, df.name == df2.name, 'inner').drop(df2.name).collect()
[Row(age=5, name=u'Bob', height=85)]
>>> df.join(df2, 'name', 'inner').drop('age', 'height').collect()
[Row(name=u'Bob')]
"""
if len(cols) == 1:
col = cols[0]
if isinstance(col, basestring):
jdf = self._jdf.drop(col)
elif isinstance(col, Column):
jdf = self._jdf.drop(col._jc)
else:
raise TypeError("col should be a string or a Column")
else:
for col in cols:
if not isinstance(col, basestring):
raise TypeError("each col in the param list should be a string")
jdf = self._jdf.drop(self._jseq(cols))
return DataFrame(jdf, self.sql_ctx)
@ignore_unicode_prefix
def toDF(self, *cols):
"""Returns a new class:`DataFrame` that with new specified column names
:param cols: list of new column names (string)
>>> df.toDF('f1', 'f2').collect()
[Row(f1=2, f2=u'Alice'), Row(f1=5, f2=u'Bob')]
"""
jdf = self._jdf.toDF(self._jseq(cols))
return DataFrame(jdf, self.sql_ctx)
@since(3.0)
def transform(self, func):
"""Returns a new class:`DataFrame`. Concise syntax for chaining custom transformations.
:param func: a function that takes and returns a class:`DataFrame`.
>>> from pyspark.sql.functions import col
>>> df = spark.createDataFrame([(1, 1.0), (2, 2.0)], ["int", "float"])
>>> def cast_all_to_int(input_df):
... return input_df.select([col(col_name).cast("int") for col_name in input_df.columns])
>>> def sort_columns_asc(input_df):
... return input_df.select(*sorted(input_df.columns))
>>> df.transform(cast_all_to_int).transform(sort_columns_asc).show()
+-----+---+
|float|int|
+-----+---+
| 1| 1|
| 2| 2|
+-----+---+
"""
result = func(self)
assert isinstance(result, DataFrame), "Func returned an instance of type [%s], " \
"should have been DataFrame." % type(result)
return result
@since(3.1)
def sameSemantics(self, other):
"""
Returns `True` when the logical query plans inside both :class:`DataFrame`\\s are equal and
therefore return same results.
.. note:: The equality comparison here is simplified by tolerating the cosmetic differences
such as attribute names.
.. note:: This API can compare both :class:`DataFrame`\\s very fast but can still return
`False` on the :class:`DataFrame` that return the same results, for instance, from
different plans. Such false negative semantic can be useful when caching as an example.
.. note:: DeveloperApi
>>> df1 = spark.range(10)
>>> df2 = spark.range(10)
>>> df1.withColumn("col1", df1.id * 2).sameSemantics(df2.withColumn("col1", df2.id * 2))
True
>>> df1.withColumn("col1", df1.id * 2).sameSemantics(df2.withColumn("col1", df2.id + 2))
False
>>> df1.withColumn("col1", df1.id * 2).sameSemantics(df2.withColumn("col0", df2.id * 2))
True
"""
if not isinstance(other, DataFrame):
raise ValueError("other parameter should be of DataFrame; however, got %s"
% type(other))
return self._jdf.sameSemantics(other._jdf)
@since(3.1)
def semanticHash(self):
"""
Returns a hash code of the logical query plan against this :class:`DataFrame`.
.. note:: Unlike the standard hash code, the hash is calculated against the query plan
simplified by tolerating the cosmetic differences such as attribute names.
.. note:: DeveloperApi
>>> spark.range(10).selectExpr("id as col0").semanticHash() # doctest: +SKIP
1855039936
>>> spark.range(10).selectExpr("id as col1").semanticHash() # doctest: +SKIP
1855039936
"""
return self._jdf.semanticHash()
where = copy_func(
filter,
sinceversion=1.3,
doc=":func:`where` is an alias for :func:`filter`.")
# Two aliases below were added for pandas compatibility many years ago.
# There are too many differences compared to pandas and we cannot just
# make it "compatible" by adding aliases. Therefore, we stop adding such
# aliases as of Spark 3.0. Two methods below remain just
# for legacy users currently.
groupby = copy_func(
groupBy,
sinceversion=1.4,
doc=":func:`groupby` is an alias for :func:`groupBy`.")
drop_duplicates = copy_func(
dropDuplicates,
sinceversion=1.4,
doc=":func:`drop_duplicates` is an alias for :func:`dropDuplicates`.")
def _to_scala_map(sc, jm):
"""
Convert a dict into a JVM Map.
"""
return sc._jvm.PythonUtils.toScalaMap(jm)
class DataFrameNaFunctions(object):
"""Functionality for working with missing data in :class:`DataFrame`.
.. versionadded:: 1.4
"""
def __init__(self, df):
self.df = df
def drop(self, how='any', thresh=None, subset=None):
return self.df.dropna(how=how, thresh=thresh, subset=subset)
drop.__doc__ = DataFrame.dropna.__doc__
def fill(self, value, subset=None):
return self.df.fillna(value=value, subset=subset)
fill.__doc__ = DataFrame.fillna.__doc__
def replace(self, to_replace, value=_NoValue, subset=None):
return self.df.replace(to_replace, value, subset)
replace.__doc__ = DataFrame.replace.__doc__
class DataFrameStatFunctions(object):
"""Functionality for statistic functions with :class:`DataFrame`.
.. versionadded:: 1.4
"""
def __init__(self, df):
self.df = df
def approxQuantile(self, col, probabilities, relativeError):
return self.df.approxQuantile(col, probabilities, relativeError)
approxQuantile.__doc__ = DataFrame.approxQuantile.__doc__
def corr(self, col1, col2, method=None):
return self.df.corr(col1, col2, method)
corr.__doc__ = DataFrame.corr.__doc__
def cov(self, col1, col2):
return self.df.cov(col1, col2)
cov.__doc__ = DataFrame.cov.__doc__
def crosstab(self, col1, col2):
return self.df.crosstab(col1, col2)
crosstab.__doc__ = DataFrame.crosstab.__doc__
def freqItems(self, cols, support=None):
return self.df.freqItems(cols, support)
freqItems.__doc__ = DataFrame.freqItems.__doc__
def sampleBy(self, col, fractions, seed=None):
return self.df.sampleBy(col, fractions, seed)
sampleBy.__doc__ = DataFrame.sampleBy.__doc__
def _test():
import doctest
from pyspark.context import SparkContext
from pyspark.sql import Row, SQLContext, SparkSession
import pyspark.sql.dataframe
from pyspark.sql.functions import from_unixtime
globs = pyspark.sql.dataframe.__dict__.copy()
sc = SparkContext('local[4]', 'PythonTest')
globs['sc'] = sc
globs['sqlContext'] = SQLContext(sc)
globs['spark'] = SparkSession(sc)
globs['df'] = sc.parallelize([(2, 'Alice'), (5, 'Bob')])\
.toDF(StructType([StructField('age', IntegerType()),
StructField('name', StringType())]))
globs['df2'] = sc.parallelize([Row(name='Tom', height=80), Row(name='Bob', height=85)]).toDF()
globs['df3'] = sc.parallelize([Row(name='Alice', age=2),
Row(name='Bob', age=5)]).toDF()
globs['df4'] = sc.parallelize([Row(name='Alice', age=10, height=80),
Row(name='Bob', age=5, height=None),
Row(name='Tom', age=None, height=None),
Row(name=None, age=None, height=None)]).toDF()
globs['df5'] = sc.parallelize([Row(name='Alice', spy=False, age=10),
Row(name='Bob', spy=None, age=5),
Row(name='Mallory', spy=True, age=None)]).toDF()
globs['sdf'] = sc.parallelize([Row(name='Tom', time=1479441846),
Row(name='Bob', time=1479442946)]).toDF()
(failure_count, test_count) = doctest.testmod(
pyspark.sql.dataframe, globs=globs,
optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF)
globs['sc'].stop()
if failure_count:
sys.exit(-1)
if __name__ == "__main__":
_test()
| mit |
paninski-lab/yass | examples/stability.py | 1 | 1887 | """
Stability metric example
"""
import os.path as path
import numpy as np
import matplotlib.pyplot as plt
from stability_evaluation import (RecordingBatchIterator, MeanWaveCalculator,
RecordingAugmentation,
SpikeSortingEvaluation)
ROOT = path.join(path.expanduser('~'), 'data/yass')
path_to_spike_train = path.join(ROOT, 'ej49_spikeTrain1_1.csv')
path_to_data = path.join(ROOT, 'ej49_data1_set1.bin')
path_to_geom = path.join(ROOT, 'ej49_geometry1.txt')
path_to_augmented = path.join(ROOT, 'augmented.bin')
spike_train = np.loadtxt(path_to_spike_train, dtype='int32', delimiter=',')
spike_train
br = RecordingBatchIterator(path_to_data, path_to_geom, sample_rate=30000,
batch_time_samples=1000000, n_batches=5,
n_chan=200, radius=100, whiten=False)
mwc = MeanWaveCalculator(br, spike_train)
# plot some of the recovered templates
for i in range(2):
plt.plot(mwc.templates[:, :, i])
plt.show()
# here we indicate what is the length of the augmented data in terms of
# batches (with respect to the batch iterator object.)
stab = RecordingAugmentation(mwc, augment_rate=0.25, move_rate=0.2)
# New ground truth spike train
new_gt_spt, status = stab.save_augment_recording(path_to_augmented, 5)
# Creating evaluation object for matching, TP, and FP
spt_ = spike_train[spike_train[:, 0] < 1e6, :]
tmp_ = mwc.templates[:, :, np.unique(spt_[:, 1])]
# Let's create a fake new spike train with only 100
# first units of the ground truth as clusters
spt_2 = spt_[spt_[:, 1] < 100, :]
tmp_2 = tmp_[:, :, :100]
# Here we just demonstrate with the sampe spike train
# The second argument should be a different spike train
ev = SpikeSortingEvaluation(spt_, spt_2, tmp_, tmp_2)
print(ev.true_positive)
print(ev.false_positive)
print(ev.unit_cluster_map)
| apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.