def __init__(self, client, eegFilePath, samplingFreq=128, channelOpt=1):
self.client = client
self.samplingFreq = samplingFreq
if channelOpt == 1:
self.useEMG = 0
if channelOpt == 2:
self.useEMG = 1
self.params = ParameterSetup()
pickledDir = self.params.pickledDir
classifierType = self.params.classifierType
classifierParams = self.params.classifierParams
# samplingFreq = self.params.samplingFreq
windowSizeInSec = self.params.windowSizeInSec
# self.wsizeInTimePoints = samplingFreq * windowSizeInSec # window size. data is sampled at 128 Hz, so 1280 sample points = 10 sec.
self.wsizeInTimePoints = self.client.updateGraph_samplePointNum
dataReader = DataReader()
print('for EEG, reading file ' + eegFilePath)
eeg, emg, timeStamps = dataReader.readEEG(eegFilePath)
# print('for stageSeq, reading file ' + stageFilePath)
# stageSeq = dataReader.readStageSeq(stageFilePath)
print('timeStamps[0] =', timeStamps[0])
print('self.samplingFreq =', self.samplingFreq)
observed_samplePointNum = self.samplingFreq * self.params.windowSizeInSec
print('observed_samplePointNum =', observed_samplePointNum)
# self.eeg = eeg
# self.emg = emg
# self.timeStamps = timeStamps
#####
model_samplingFreq = 128
model_samplePointNum = model_samplingFreq * 10
#######
self.eeg = up_or_down_sampling(eeg, model_samplePointNum,
observed_samplePointNum)
self.emg = up_or_down_sampling(emg, model_samplePointNum,
observed_samplePointNum)
self.timeStamps = self.convertTimeStamps(timeStamps,
model_samplingFreq,
model_samplePointNum,
observed_samplePointNum)
self.wNum = self.eeg.shape[0]
presentTime = timeFormatting.presentTimeEscaped()
fileName = 'daq.' + presentTime + '.csv'
self.logFile = open(self.params.logDir + '/' + fileName, 'a')
self.serve()
### chamberNum = 2
# chamberNum = 1
params = ParameterSetup()
all_postFiles = listdir(params.postDir)
postFiles = []
for fileName in all_postFiles:
if fileName[0] != '.':
postFiles.append(fileName)
print('postFiles =', postFiles)
eegFilePathL = []
eegL = []
for _, inputFileName in zip(range(chamberNum), postFiles):
dataReader = DataReader()
eegFilePath = params.postDir + '/' + inputFileName
print('for EEG, reading file ' + eegFilePath)
eeg, emg, timeStamps = dataReader.readEEG(eegFilePath)
eegFilePathL.append(eegFilePath)
eegL.append(eeg)
max_eegLength = reduce(max, [len(eeg) for eeg in eegL])
print('max_eegLen =', max_eegLength)
epochNum = np.int(np.floor(max_eegLength / epochSampleNum))
print('epochNum =', epochNum)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((server_HOST, server_PORT))
import serial
import serial.tools.list_ports
import time
import sys
import datetime
import matplotlib.pyplot as plt
from dataReader import DataReader
from fileLogger import FileLogger
from plotter import Plotter
from pyLive import live_plotter_xy
dataReader = DataReader("USB-SERIAL CH340 (COM4)")
fileLogger = FileLogger("datalog.csv")
plotter = Plotter()
if dataReader.serialPort == None:
print("Port not found")
sys.exit()
line1 = []
try:
for data in dataReader():
plotter.append(data)
line1 = live_plotter_xy(plotter.x_axis, plotter.batteryVoltage, line1)
fileLogger.append(data)
except KeyboardInterrupt:
fileLogger.close()
sys.exit()
def batchClassifySequentially(eegFilePath, stagePredictor):
dataReader = DataReader()
eeg, emg, timeStamps = dataReader.readEEG(eegFilePath)
print('eeg.shape = ' + str(eeg.shape))
samplePointNum = eeg.shape[0]
# reset eeg and emg statistical values
eeg_mean = 0
eeg_variance = 0
emg_mean = 0
emg_variance = 0
oldSampleNum = 0
y_pred_L = []
wID = 0
# startSamplePoint = 0
stagePredictions_L = []
replacedR = False
# while startSamplePoint + wsizeInSamplePointNum <= samplePointNum:
records_L = []
timeStampSegments_L = []
for startSamplePoint in range(0, samplePointNum,
timeWindowStrideInSamplePointNum):
endSamplePoint = startSamplePoint + wsizeInSamplePointNum
if endSamplePoint > samplePointNum:
break
eegSegment = eeg[startSamplePoint:endSamplePoint]
eegSegment_orig_mean = np.mean(eegSegment)
eegSegment_orig_std = np.std(eegSegment)
eeg_old_mean = eeg_mean
eeg_mean = recompMean(eegSegment, eeg_mean, oldSampleNum)
eeg_variance = recompVariance(eegSegment, eeg_variance, eeg_old_mean,
eeg_mean, oldSampleNum)
standardized_eegSegment = (eegSegment -
eeg_mean) / np.sqrt(eeg_variance)
if params.useEMG:
emgSegment = emg[startSamplePoint:endSamplePoint]
emg_old_mean = emg_mean
emg_mean = recompMean(emgSegment, emg_mean, oldSampleNum)
emg_variance = recompVariance(emgSegment, emg_variance,
emg_old_mean, emg_mean, oldSampleNum)
standardized_emgSegment = (emgSegment -
emg_mean) / np.sqrt(emg_variance)
one_record = np.r_[standardized_eegSegment,
standardized_emgSegment]
else:
one_record = standardized_eegSegment
oldSampleNum += eegSegment.shape[0]
local_mu = np.mean(standardized_eegSegment)
local_sigma = np.std(standardized_eegSegment)
timeStampSegment = timeStamps[startSamplePoint:endSamplePoint]
# if predict_by_batch:
records_L.append(one_record)
timeStampSegments_L.append(timeStampSegment)
'''
else:
stagePrediction = params.reverseLabel(stagePredictor.predict(one_record, timeStampSegment, local_mu=local_mu, local_sigma=local_sigma))
# print('after stagePredictor.predict')
# replaces R to W when W appears consecutively
Ws = 'W' * numOfConsecutiveWsThatProhibitsR
for wCnt in range(1,numOfConsecutiveWsThatProhibitsR+1):
if len(y_pred_L) >= wCnt:
if y_pred_L[len(y_pred_L)-wCnt] != 'W':
break
if stagePrediction == 'R':
print(Ws + '->R changed to ' + Ws + '->W at wID = ' + str(wID) + ', startSamplePoint = ' + str(startSamplePoint))
stagePrediction = 'W'
replacedR = True
#----
# if the prediction is P, then use the previous one
if stagePrediction == 'P':
# print('stagePrediction == P for wID = ' + str(wID))
if len(y_pred_L) > 0:
stagePrediction = y_pred_L[len(y_pred_L)-1]
else:
stagePrediction = 'M'
#-----
# vote for choosing the label for 10 second window
stagePredictions_L.append(stagePrediction)
if len(stagePredictions_L) == strideNumInTimeWindow:
finalStagePrediction = voteForStagePrediction(stagePredictions_L[-(lookBackTimeWindowNum+1):])
#-----
# append to the lists of results
y_pred_L.append(finalStagePrediction)
if predict_by_batch:
'''
### y_pred = np.array([params.reverseLabel(y_pred_orig) for y_pred_orig in stagePredictor.batch_predict(np.array(records_L), np.array(timeStampSegments_L), local_mu=local_mu, local_sigma=local_sigma)])
y_pred = np.array([
params.capitalize_for_writing_prediction_to_file[y_pred_orig]
for y_pred_orig in stagePredictor.batch_predict(
params,
np.array(records_L),
np.array(timeStampSegments_L),
local_mu=local_mu,
local_sigma=local_sigma)
])
'''
else:
y_pred = np.array(y_pred_L)
'''
return y_pred
if args.splitFlag == 'T':
randomCropFlag = False
else:
randomCropFlag = True
with tf.device('/CPU:0'):
with tf.name_scope("testinputs"):
reader = DataReader(datasplitter.data_home,
datasplitter.dataset_name,
datasplitter.test_tags,
params,
coord,
dataset_catgry=datasplitter.dataset_catgry,
random_scale=False,
random_mirror=False,
gt_type='annotated',
random_crop=randomCropFlag,
data_type=1,
dataoption=dataoption,
queue_flag=False)
dataparams.num_channels = reader.channelinfo.depth_nchannels
dataparams.channelinfo = reader.channelinfo
queue_list = tf.placeholder(tf.string, [3])
testdata_batch, testlabel_batch = reader.read_data_from_disk(queue_list)
BATCH_SIZE = 1
from dataReader import DataReader as DR
pattern = ''.center(20, '*')
print('Welcome to the muj Department electives 2021 visualizer.\n')
print(pattern + '\n\n')
choice = True
dataReader = None
while (choice):
print('Select one of the options below\n')
print(pattern + '\n\n')
print(
'1>Visualize the class wise department elective chosen\n2>Number of students in each section of each department\n3>Exit the programme\n\n'
)
optionSelected = int(input('Your choice : '))
if optionSelected == 3:
break
elif optionSelected > 3 or optionSelected < 1:
print('Invalid option selected . Please enter again\n\n')
else:
if not dataReader:
dataReader = DR()
dataReader.readExcelFile('deData')
if optionSelected == 1:
dataReader.plotGraphForDe()
elif optionSelected == 2:
dataReader.plotGraphForStudents()
else:
print('Invalid Credential Entered\n\n')
networkparams.dtype = DEFAULT_DTYPE
#os.environ["CUDA_VISIBLE_DEVICES"] = ''
tf.set_random_seed(666)
coord = tf.train.Coordinator()
with tf.device('/CPU:0'):
with tf.name_scope("traininginputs"):
reader = DataReader(datasplitter.data_home,
datasplitter.dataset_name,
datasplitter.training_tags,
params,
coord,
dataset_catgry=datasplitter.dataset_catgry,
random_scale=False,
random_mirror=True,
gt_type='annotated',
random_crop=True,
data_type=1,
dataoption='color_dc_dcclabels',
queue_flag=True,
num_preprocess_threads=16)
traindata_batch, trainlabel_batch = reader.dequeue(BATCH_SIZE)
with tf.name_scope("validationinputs"):
reader = DataReader(datasplitter.data_home,
datasplitter.dataset_name,
datasplitter.validation_tags,
params,
coord,
import pandas as pd
import numpy as np
from paramOptimizer import ParamOptimizer
from kalmanCalculator import KalmanCalculator
from scipy.optimize import differential_evolution
from dataReader import DataReader
from graphMaker import GraphMaker
if __name__ == '__main__':
print(__doc__)
startCalTime = datetime.datetime.now()
# データ入力
# ----------------------------------------
allDataDF = pd.DataFrame()
dataReader = DataReader(allDataDF)
cal_settings = dataReader.getCalSettings()
forecast = cal_settings["forecast"]
dataReader.putTime(cal_settings["startTime"], cal_settings["endTime"],
cal_settings["timeInterval"], cal_settings["timescale"])
dataReader.setInputFilePath()
if cal_settings["used_rainfallData"]:
# 雨量 (mm/hr)
dataReader.readRainfallData(cal_settings["used_rainfallData"],
cal_settings["timeInterval"],
cal_settings["timescale"],
cal_settings["startTime"],
cal_settings["endTime"])
if cal_settings["used_waterLevelData"]:
# 水位 (m)
import sys from dataReader import DataReader dataReader = DataReader() dataReader.readAll(sys)
def __init__(self, infile, table_name, config, batch_size):
self.config = config
self.data_reader = DataReader(infile)
self.table_name = table_name
self.sql_statements = SQLStatements(self.table_name)
self.batch_size = batch_size