I have hit a mental road block here, or perhaps too much coding and cant think straight.
I have a simple program to model the output of a factor including existing factories with a known production profile (decays each year) along with new factories adding for the next few years.
The goal is to get a total production series which incorporates both. Hopefully the comments in the code better indicate what my issues are.
import pandas as pd
#constants
inv_yr = 5 # years of making new investments
asset_life = 30 # years of production for new factor
# creates blank time series
new_factory_adds = pd.Series(0, index=range(1,asset_life + inv_yr +1), name = 'new factories')
production = pd.Series(0, index=range(1,asset_life+1))
# Fill series of new factory adds
for i in range(1, inv_yr+1):
new_factory_adds[i] = 2 # means for first 5 years 2 are added each yr.
# Fill series of a new individual production line
for j in range(1,asset_life+1):
if j ==1:
production[j] = 100
else:
production[j] = production[j-1]*0.95
# to calculate total production for each year...
# create blank time series
tot_prod = pd.Series(0, index=range(1,asset_life + inv_yr+1),name='Tot Prod')
# data frame to combined
df = pd.concat([new_factory_adds,tot_prod],axis=1)
print(df)
# fill Tot Production series - this is where i am having difficuilties
for k in range(1, asset_life + inv_yr+1):
if k ==1:
tot_prod=new_factory_adds[k]*production[k]
elif:
k<=inv_yr:
tot_prod=new_factory_adds[k]*production[k] + production[k-1]
Related
I build an support/resistance like feature for my deep learning model (cryptocurrency prediction). The newly trained model's results are very good, with the normal evaluation the results are also very good. But with an evaluation that only predicts on the last sample in the dataframe the results are not nearly as good. The evaluation is done over the same period with the same amount of samples.
So I am concerned that the support/resistance feature uses future data somehow. I have had this issue before when I made the code for the first time but I already fixed that error. So does anyone have any ideas if this code does indeed use future data which would not be possible in real-life.
This problem happened since this new feature so the rest of the code is good.
The code works like the following, it retrieves the high & low per slices of 12 samples. Then it fills in the value of the high/low from the point itself till just before the next high/low.
Code:
# find lows & highs in window.
lows, highs = [], []
max = int(len(df) / window)
diff = len(df) - (max * window)
for index in range(max):
if index == 0:
sliced = df.iloc[index*window: ((index+1)*window)+diff]
else:
sliced = df.iloc[(index*window)+diff: ((index+1)*window)+diff]
high = sliced["high"].max()
index = sliced.index[sliced['high'] == high].tolist()[0]
highs.append([index, high])
low = sliced["low"].min()
index = sliced.index[sliced['low'] == low].tolist()[0]
lows.append([index, low])
# fill in highs.
max = len(highs)
filled = []
for index in range(max):
if index == 0: # this does fill in future data but the first rows are always dropped past this because of other features so this is not the problem.
for i in range(0, highs[index][0]):
filled.append([i, highs[index][1]])
if index < max-1:
for i in range(highs[index][0], highs[index+1][0]):
filled.append([i, highs[index][1]])
elif index == max-1:
for i in range(highs[index][0], len(df)):
filled.append([i, highs[index][1]])
highs = filled
# fill in lows.
max = len(lows)
filled = []
for index in range(max):
if index == 0: # this does fill in future data but the first rows are always dropped past this because of other features so this is not the problem.
for i in range(0, lows[index][0]):
filled.append([i, lows[index][1]])
if index < max-1:
for i in range(lows[index][0], lows[index+1][0]):
filled.append([i, lows[index][1]])
elif index == max-1:
for i in range(lows[index][0], len(df)):
filled.append([i, lows[index][1]])
lows = filled
# fill support & resistance into df.
for index, high in highs:
df.at[index, "resistance"] = high
for index, low in lows:
df.at[index, "support"] = low
return df[["support", "resistance"]]
As a candlestick graph it would look like this. The purple points are the new highs and lows.
Does anyone see some kind of error which could make the feature use future data that is not available in real-life and therefore could explain the differences between the evaluations?
I have a set of 100 diseased people. According to data, the probability of them getting themselves reported/tested is 0.03. Let us assume that the count of the diseased remains a constant over 10 days. How do I implement the logic so that at the end of 10 days, 3-4 diseased people get reported? Assuming that the resolution of time chosen is 1-day. A small example of the current implementation is given below:
import numpy as np
Population = 1000 # Total Population
# Store Infection Status
Infection_status = np.zeros(Population)
# Total Infections
Infection_status[:100] = 1
# Store Test Status
Test_status = np.zeros(Population)
for t in range(10):
# generate N random numbers
temp = np.random.uniform(0,1,Population)
# Choose 1 in 30
Test_status[(temp<0.03) & (Infection_status==1)] = 1
I have data from eye-tracking (.edf file - from Eyelink by SR-research). I want to analyse it and get various measures such as fixation, saccade, duration, etc.
Is there an existing package to analyse Eye-Tracking data?
Thanks!
At least for importing the .edf-file into a pandas DF, you can use the following package by Niklas Wilming: https://github.com/nwilming/pyedfread/tree/master/pyedfread
This should already take care of saccades and fixations - have a look at the readme. Once they're in the data frame, you can apply whatever analysis you want to it.
pyeparse seems to be another (yet currently unmaintained as it seems) library that can be used for eyelink data analysis.
Here is a short excerpt from their example:
import numpy as np
import matplotlib.pyplot as plt
import pyeparse as pp
fname = '../pyeparse/tests/data/test_raw.edf'
raw = pp.read_raw(fname)
# visualize initial calibration
raw.plot_calibration(title='5-Point Calibration')
# create heatmap
raw.plot_heatmap(start=3., stop=60.)
EDIT: After I posted my answer I found a nice list compiling lots of potential tools for eyelink edf data analysis: https://github.com/davebraze/FDBeye/wiki/Researcher-Contributed-Eye-Tracking-Tools
Hey the question seems rather old but maybe I can reactivate it, because I am currently facing the same situation.
To start I recommend to convert your .edf to an .asc file. In this way it is easier to read it to get a first impression.
For this there exist many tools, but I used the SR-Research Eyelink Developers Kit (here).
I don't know your setup but the Eyelink 1000 itself detects saccades and fixation. I my case in the .asc file it looks like that:
SFIX L 10350642
10350642 864.3 542.7 2317.0
...
...
10350962 863.2 540.4 2354.0
EFIX L 10350642 10350962 322 863.1 541.2 2339
SSACC L 10350964
10350964 863.4 539.8 2359.0
...
...
10351004 683.4 511.2 2363.0
ESACC L 10350964 10351004 42 863.4 539.8 683.4 511.2 5.79 221
The first number corresponds to the timestamp, the second and third to x-y coordinates and the last is your pupil diameter (what the last numbers after ESACC are, I don't know).
SFIX -> start fixation
EFIX -> end fixation
SSACC -> start saccade
ESACC -> end saccade
You can also check out PyGaze, I haven't worked with it, but searching for a toolbox, this one always popped up.
EDIT
I found this toolbox here. It looks cool and works fine with the example data, but sadly does not work with mine
EDIT No 2
Revisiting this question after working on my own Eyetracking data I thought I might share a function wrote, to work with my data:
def eyedata2pandasframe(directory):
'''
This function takes a directory from which it tries to read in ASCII files containing eyetracking data
It returns eye_data: A pandas dataframe containing data from fixations AND saccades fix_data: A pandas dataframe containing only data from fixations
sac_data: pandas dataframe containing only data from saccades
fixation: numpy array containing information about fixation onsets and offsets
saccades: numpy array containing information about saccade onsets and offsets
blinks: numpy array containing information about blink onsets and offsets
trials: numpy array containing information about trial onsets
'''
eye_data= []
fix_data = []
sac_data = []
data_header = {0: 'TimeStamp',1: 'X_Coord',2: 'Y_Coord',3: 'Diameter'}
event_header = {0: 'Start', 1: 'End'}
start_reading = False
in_blink = False
in_saccade = False
fix_timestamps = []
sac_timestamps = []
blink_timestamps = []
trials = []
sample_rate_info = []
sample_rate = 0
# read the file and store, depending on the messages the data
# we have the following structure:
# a header -- every line starts with a '**'
# a bunch of messages containing information about callibration/validation and so on all starting with 'MSG'
# followed by:
# START 10350638 LEFT SAMPLES EVENTS
# PRESCALER 1
# VPRESCALER 1
# PUPIL AREA
# EVENTS GAZE LEFT RATE 500.00 TRACKING CR FILTER 2
# SAMPLES GAZE LEFT RATE 500.00 TRACKING CR FILTER 2
# followed by the actual data:
# normal data --> [TIMESTAMP]\t [X-Coords]\t [Y-Coords]\t [Diameter]
# Start of EVENTS [BLINKS FIXATION SACCADES] --> S[EVENTNAME] [EYE] [TIMESTAMP]
# End of EVENTS --> E[EVENT] [EYE] [TIMESTAMP_START]\t [TIMESTAMP_END]\t [TIME OF EVENT]\t [X-Coords start]\t [Y-Coords start]\t [X_Coords end]\t [Y-Coords end]\t [?]\t [?]
# Trial messages --> MSG timestamp\t TRIAL [TRIALNUMBER]
try:
with open(directory) as f:
csv_reader = csv.reader(f, delimiter ='\t')
for i, row in enumerate (csv_reader):
if any ('RATE' in item for item in row):
sample_rate_info = row
if any('SYNCTIME' in item for item in row): # only start reading after this message
start_reading = True
elif any('SFIX' in item for item in row): pass
#fix_timestamps[0].append (row)
elif any('EFIX' in item for item in row):
fix_timestamps.append ([row[0].split(' ')[4],row[1]])
#fix_timestamps[1].append (row)
elif any('SSACC' in item for item in row):
#sac_timestamps[0].append (row)
in_saccade = True
elif any('ESACC' in item for item in row):
sac_timestamps.append ([row[0].split(' ')[3],row[1]])
in_saccade = False
elif any('SBLINK' in item for item in row): # stop reading here because the blinks contain NaN
# blink_timestamps[0].append (row)
in_blink = True
elif any('EBLINK' in item for item in row): # start reading again. the blink ended
blink_timestamps.append ([row[0].split(' ')[2],row[1]])
in_blink = False
elif any('TRIAL' in item for item in row):
# the first element is 'MSG', we don't need it, then we split the second element to seperate the timestamp and only keep it as an integer
trials.append (int(row[1].split(' ')[0]))
elif start_reading and not in_blink:
eye_data.append(row)
if in_saccade:
sac_data.append(row)
else:
fix_data.append(row)
# drop the last data point, because it is the 'END' message
eye_data.pop(-1)
sac_data.pop(-1)
fix_data.pop(-1)
# convert every item in list into a float, substract the start of the first trial to set the start of the first video to t0=0
# then devide by 1000 to convert from milliseconds to seconds
for row in eye_data:
for i, item in enumerate (row):
row[i] = float (item)
for row in fix_data:
for i, item in enumerate (row):
row[i] = float (item)
for row in sac_data:
for i, item in enumerate (row):
row[i] = float (item)
for row in fix_timestamps:
for i, item in enumerate (row):
row [i] = (float(item)-trials[0])/1000
for row in sac_timestamps:
for i, item in enumerate (row):
row [i] = (float(item)-trials[0])/1000
for row in blink_timestamps:
for i, item in enumerate (row):
row [i] = (float(item)-trials[0])/1000
sample_rate = float (sample_rate_info[4])
# convert into pandas fix_data Frames for a better overview
eye_data = pd.DataFrame(eye_data)
fix_data = pd.DataFrame(fix_data)
sac_data = pd.DataFrame(sac_data)
fix_timestamps = pd.DataFrame(fix_timestamps)
sac_timestamps = pd.DataFrame(sac_timestamps)
trials = np.array(trials)
blink_timestamps = pd.DataFrame(blink_timestamps)
# rename header for an even better overview
eye_data = eye_data.rename(columns=data_header)
fix_data = fix_data.rename(columns=data_header)
sac_data = sac_data.rename(columns=data_header)
fix_timestamps = fix_timestamps.rename(columns=event_header)
sac_timestamps = sac_timestamps.rename(columns=event_header)
blink_timestamps = blink_timestamps.rename(columns=event_header)
# substract the first timestamp of trials to set the start of the first video to t0=0
eye_data.TimeStamp -= trials[0]
fix_data.TimeStamp -= trials[0]
sac_data.TimeStamp -= trials[0]
trials -= trials[0]
trials = trials /1000 # does not work with trials/=1000
# devide TimeStamp to get time in seconds
eye_data.TimeStamp /=1000
fix_data.TimeStamp /=1000
sac_data.TimeStamp /=1000
return eye_data, fix_data, sac_data, fix_timestamps, sac_timestamps, blink_timestamps, trials, sample_rate
except:
print ('Could not read ' + str(directory) + ' properly!!! Returned empty data')
return eye_data, fix_data, sac_data, fix_timestamps, sac_timestamps, blink_timestamps, trials, sample_rate
Hope it helps you guys. Some parts of the code you may need to change, like the index where to split the strings to get the crutial information about event on/offsets. Or you don't want to convert your timestamps into seconds or do not want to set the onset of your first trial to 0. That is up to you.
Additionally in my data we sent a message to know when we started measuring ('SYNCTIME') and I had only ONE condition in my experiment, so there is only one 'TRIAL' message
Cheers
So I'm creating a master program for machine learning from scratch in python and the first step i want to do is to check if the data set is normal or not.
ps : the data set can have many features or just a single feature.
It has to be implemented in python3.
also, normalizing the data can be done by the below function right :
# Find the min and max values for each column
def dataset_minmax(dataset):
minmax = list()
for i in range(len(dataset[0])):
col_values = [row[i] for row in dataset]
value_min = min(col_values)
value_max = max(col_values)
minmax.append([value_min, value_max])
return minmax
# Rescale dataset columns to the range 0-1
def normalize_dataset(dataset, minmax):
for row in dataset:
for i in range(len(row)):
row[i] = (row[i] - minmax[i][0]) / (minmax[i][1] - minmax[i][0])
THANKS IN ADVANCE!
Your question seems discordant: if your features are not coming from a normal distribution, you cannot "normalize" them, in the sense of changing their distribution. If you mean to check if they have average 0 and SD of 1 that is a different ballpark game.
I have a test list of 10,000 IDs and this is what I have to do:
For every test ID, calculate rank by comparing with other IDs i.e. people from same company
Check if the rank for this test ID is above 'normal' by a) calculating ranks (same as step 1) of 1000 randomly selected IDs b) comparing these 1000 ranks with the rank of test ID
Do this (step 1 and 2) for 10,000 test IDs with data from 10 different months.
To store the master data of 14000 IDs and observation for 10 months I am using sqlite as it makes querying and ranking easier and faster.
To reduce the run time, I am using 'multiprocessing' and parallelize calculations on number of months i.e. ranks calculated for different months on different cores. This works well for less number of test IDs (<=2000) or less random ranks (>=200) but if I calculate ranks for all 10 months in parallel and using 1000 as number of random ranks for each ID than the script freezes after a few hours. No error is provided. I believe SQLite is the culprit and need your help to figure out the issue.
Here is my code:
nproc = 10 ## Number of cores
randNum = 1000 ## Number of random ranks for each ID
def main():
'''
This will go through every specified column one by one, and for each entry
a rank of entry will be computed which is comapred with ranks of randomly selected 1000 entries from same column
'''
## Read master file with 14000 rows X 20 cols, each row pertains to an ID/ID,
## first 9 columns have info related to ID and last 10 have observed values from 10 diff. months
resList = List with 14000 entries Eg. [(123,"ABC",.....),(234,"DEF",........)....14000n]
## Read test file, for which ranks to be calculated. Contains 10,000 IDs/IDs and their names
global testIDList ## for p-value calculation
testIDList = List with 1000 entries Eg. [(123,"ABC"),(234,"DEF")..10,000n]
## Create identifier SET - Used for random selection of IDs
global idSET ## USed in rankCalcTest
idSET = SET OF ALL IDs FROM MASTER FILE
global trackTableName,coordsDB,chrLimit ## Globals for all other functions
## Specify column numbers in master file that have values for each ID from different months
trackList = [10,11,12,13,14,15,16,17,18,19,20] ## Columns in file with 14000 rows each.
### Parallel
allTrackPvals = PPResults(rankCalcTest,trackList)
DO SOME PROCESSING
SCRIPT ENDS
def rankCalcTest(col):
'''
Calculates ranks for test IDs using column/month specified by 'main()' function
'''
DB = '%s_%s.db' % (coordsDB.split('.')[0],col) ## New DB for every column/month - Because current function is paralleized so every core works on a column/month
conn = sqlite3.connect(DB)
trackPvals = [] ## Temporary list that will hold ranks for single column/month
tableCols = [col] ## Column with observed values from an month, that will be used to generate column-specific ranks
## Make sqlite3 table for current track
trackTableName = 'track_%s' % (col) ## Here a table is created containing all IDs and observations from specifc column
trackTableName = tableMaker(trackTableName,annoDict,resList,tableCols,conn) ## This modules not included in example, as it works well -uses SQLite
chrLimit = chrLimits(trackTableName,conn) ## This module not included in examples as it works well - uses SQLite
for ent in testIDList: ## Total 10,000 entries
## Generate Relative Rank for ID/ of interest
mainID = ent[0] ## ID number
mainRank = rankGenerator(mainID,trackTableName,chrLimit,conn) ## See below for function
randomIDs = randomSelect(idSET,randNum)
randomRanks = []
for randID in randomIDs:
randomRank = rankGenerator(randID,trackTableName,chrLimit,conn)
randomRanks.append(randomRank)
### Some calculation
probRR = DO SOME CALCULATION
trackPvals.append(round(probRR,5))
conn.close()
return trackPvals
def rankGenerator(ID,trackTableName,chrLimit,conn):
'''
Generate a rank for each ID provided by 'rankCalcTest' function
'''
print ('\nRank is being calculated for ID:%s' % (ID))
IDCoord = aDict[ID] ## Get required info to construct the read query
company = IDCoord[0]
intervalIDs = [] ## List to hold all the IDs in an interval
rank = 0 ##Initialize
cur = conn.cursor()
print ('ID class 0')
cur.execute("SELECT ID,hours FROM %s WHERE chr = '%s' AND start between %s and %s ORDER BY hours desc" % (trackTableName,comapny))
intIDs = cur.fetchall()
intervalIDs.extend(intIDs) ## There is one ore query in certain cases, removed for brewity of code
Rank = SOME CALCULATION
print('Relative Rank for %s: %s'% (ID,str(weigRelativeRank)))
return Rank
def PPResults(module,alist):
npool = Pool(int(nproc))
res = npool.map_async(module, alist)
results = (res.get())
return results
The script freezes in 'rankGenerator' function:
Rank is being calculated for ID:1423187_at
Rank is being calculated for ID:1452528_a_at
Coordinates found for:1423187_at - 8,111940709,111952915
Coordinates found for:1452528_a_at - 19,43612500,43614912
ID class 0
As, the run was performed in parallel its hard to say at which line script is freezing but seems like the query in 'rankGenerator' is the freezing point. Is it related to locks in SQLite?
Sorry for large code. It is actually a very trimmed version that took me 3 hrs to prepare. I hope to get some help.
AK