def queries(training_set, test_set, train_vectors, test_vectors, path):
threshold_start = 1
threshold_end = 10
thresholds = []
metrics_obj_list = []
for i in range(threshold_start, threshold_end + 1):
thresholds.append(i)
metrics_obj_list.append(Metrics())
fw = FileWriter(path)
eval = Evaluator(training_set)
for i in range(len(test_vectors)):
scores = query(train_vectors, test_vectors[i], threshold_end)
query_doc = test_set[i]
for j in range(len(thresholds)):
threshold = thresholds[j]
eval.query([training_set[x] for (x, y) in scores[0:threshold]],
query_doc)
eval.calculate()
metrics_obj_list[j].updateConfusionMatrix(eval)
metrics_obj_list[j].updateMacroAverages(eval)
for obj in metrics_obj_list:
obj.calculate(len(test_set))
fw.writeToFiles(metrics_obj_list, thresholds)
def write_file(self, name, obj, dest):
if hasattr(obj, 'toData'):
data = obj.toData()
path, name = os.path.split(name)
name = self.get_file_name(obj, name)
log.info("Extracting %s to %s...", name, dest + '/' + name)
if not self.readOnly:
with FileWriter(dest + '/' + name) as output:
output.write(data)
else:
for obj in obj.objects:
self.write_file(name, obj, dest)
def mkfile(self, path:Path, mode:fopenMode='wb') -> BinOutput:
"""Create a file within the output directory.
Allows multiple nested paths. Creates the directories as needed.
Returns the file object.
"""
log.debug("%s.mkfile(%s) dest=%s", type(self).__name__,
path, self.destPath)
_, name = os.path.split(self.input.name)
path += '/' + name + '.' + self.defaultFileExt
#path = self.destPath + '/' + path
if self.dry: return DummyFileWriter(path, mode)
return FileWriter(path, mode)
def extract_recursive(self, path, dest):
with self.makeFileReader(path) as file:
decoder = codec.getDecoderForFile(file)
decoder = decoder(file, None)
log.debug("get_files(%s, %s)", decoder, path)
items = self.get_files(decoder, path)
for item in items:
log.info("Extracting %s/%s...", dest, item['name'])
if not self.readOnly:
with FileWriter(dest + '/' + item['name']) as output:
if 'file' in item:
item['file'].seek(0)
output.write(item['file'].read())
else:
output.write(item['obj'].toData())
def __init__(self, initial_vaccinated, initial_infected, initial_healthy, virus, resultsfilename):
'''Set up the initial simulation values'''
self.virus = virus
self.initial_infected = initial_infected
self.initial_healthy = initial_healthy
self.initial_vaccinated = initial_vaccinated
self.population = []
self.population_size = initial_infected + initial_healthy + initial_vaccinated
self.total_dead = 0
self.total_vaccinated = initial_vaccinated
self.file_writer = FileWriter(resultsfilename)
def unpack(self):
"""Unpack this file to `self.destPath`."""
objs = list(self._iter_objects())
for obj in objs:
name = obj.name
if name == '' or name.startswith('.'):
log.warning("Object named '%s' output to '%s'",
name, 'data'+name)
name = 'data'+name
if hasattr(obj, 'defaultFileExt'):
name += '.' + obj.defaultFileExt
if self.destPath != '':
name = self.destPath+'/'+name
log.info('Extract "%s" to "%s"', obj.name, name)
with FileWriter(name) as file:
file.write(obj.toData())
from filewriter import FileWriter
if len(sys.argv) > 1:
log = sys.argv[1] # name of log file
else:
log = 'webmet.log' # default log file
if len(sys.argv) > 2:
n = int(sys.argv[2]) # number of observations
else:
n = 10 # default single observation
if len(sys.argv) > 3:
delay = int(sys.argv[3]) # delay between observations (sec)
else:
delay = 30 # default delay 30 sec
if len(sys.argv) > 4:
elevation = float(sys.argv[4]) # elevation of start point
else:
elevation = 100 # default elevation for start point
mu = WebMetMeasureUnit(
msg="q=budapest&appid=13152b0308b85a39cc9a161e241ec2cf")
wi = WebIface("demo", "http://api.openweathermap.org/data/2.5/weather",
"json")
fw = FileWriter(fname=log,
filt=['pressure', 'temp', 'humidity', 'datetime'])
web = WebMet('WebMet', mu, wi)
for i in range(n):
data = web.GetPressure()
data['temp'] = web.GetTemp()['temp']
fw.WriteData(data)
print(data)
time.sleep(delay)
def false_positive(self, partitions: ClusterPoints,
clusters: ClusterPoints):
return self.sum_of_pairs(clusters) - self.true_positive(
partitions, clusters)
@staticmethod
def sum_of_pairs(cluster_points: ClusterPoints):
combinations = 0
for cluster_id in cluster_points.cluster_ids():
cluster_count = cluster_points.points_count(cluster_id)
combinations += cluster_count * (cluster_count - 1)
return combinations / 2
nmi = ClusterEvaluator(NormalizedMutualInformation(), FileReader("", " "))
jcs = ClusterEvaluator(JaccardSimilarity(), FileReader("", " "))
results = list()
for iii in range(1, 6):
nmi_result = nmi.evaluate("data/partitions.txt",
"data/clustering_" + str(iii) + ".txt")
jcs_result = jcs.evaluate("data/partitions.txt",
"data/clustering_" + str(iii) + ".txt")
print("////// " + str(iii) + " ///////")
print(nmi_result)
print(jcs_result)
print()
results.append([nmi_result, jcs_result])
writer = FileWriter("data/scores.txt", " ")
writer.write_list_of_rows_to_file(results)
from trimble5500 import Trimble5500
mu = Trimble5500()
else:
print "unsupported instrument type"
#sys.exit(1)
# set port
port = 'COM5'
if len(sys.argv) > 4:
port = sys.argv[4]
iface = SerialIface("test", port)
# set output file name
fn = 'measmtrx.txt'
if len(sys.argv) > 5:
fn = sys.argv[5]
# write out measurements
wrt = FileWriter(angle='DEG', dist='.3f', fname=fn)
if wrt.GetState() != wrt.WR_OK:
sys.exit(-1) # open error
ts = TotalStation(stationtype, mu, iface, wrt)
ts.SetATR(0) # turn ATR off
ts.SetEDMMode('RLSTANDARD') # reflectorless distance measurement
ts.SetRedLaser(1) # turn red laser on
w = raw_input("Target on lower left corner and press Enter")
w1 = ts.GetAngles()
w = raw_input("Target on upper right corner and press Enter")
w2 = ts.GetAngles()
dh = (w2['hz'].GetAngle() - w1['hz'].GetAngle()) / dh_nr
dv = (w2['v'].GetAngle() - w1['v'].GetAngle()) / dv_nr
# measurement loops
if len(sys.argv) > 1:
cm = sys.argv[1]
else:
cm = '/dev/ttyUSB0'
if re.search('COM[0-9]$', cm) or '/dev/ttyUSB0' == cm:
from serialiface import SerialIface
iface = SerialIface('test', cm)
else:
from bluetoothiface import BluetoothIface
iface = BluetoothIface('test', cm, 1)
#from localiface import LocalIface
#iface = LocalIface('test', 'output.nmea')
from nmeagnssunit import NmeaGnssUnit
from filewriter import FileWriter
from gnss import Gnss
#Making measurement unit
mu = NmeaGnssUnit()
#Writer unit creating
if len(sys.argv) > 2:
fn = sys.argv[2]
else:
fn = 'stdout'
wrt = FileWriter('', 'DEG', '.3f', '%Y-%m-%d %H:%M:%S', None, fn)
#Get NMEA data
g = Gnss('', mu, iface, wrt)
while g.measureIface.state == g.measureIface.IF_OK:
g.Measure()
session = requests.Session()
start_time = getTime()
training_set_json = json.load(open(training_set_path))["documents"]
if test_set_limit != -1:
test_set = json.load(open(test_set_path))["documents"][0:test_set_limit]
else:
test_set = json.load(open(test_set_path))["documents"]
test_set_pmids = [doc["pmid"] for doc in test_set]
tlog("Test set read.")
fw = FileWriter()
for i in range(threshold_start, threshold_end + 1):
thresholds.append(i)
metrics_obj_list.append(Metrics())
eval = Evaluator()
doc_results = {}
results_file = open("results.json", "r")
pmid_results = json.load(results_file)
result_documents_file = open("result_documents.json", "r")
result_documents = json.load(result_documents_file)
def __init__(self, log_file_path, callback):
self.logger = logging.getLogger(self.__class__.__name__)
super(SerialFileWriter, self).__init__(self.__class__.__name__)
self._file_writer = FileWriter(log_file_path, callback)
log = sys.argv[1] # name of log file
else:
log = 'bmp180.log' # default log file
if len(sys.argv) > 2:
n = int(sys.argv[2]) # number of observations
else:
n = 10 # default single observation
if len(sys.argv) > 3:
delay = int(sys.argv[3]) # delay between observations (sec)
else:
delay = 30 # default delay 30 sec
if len(sys.argv) > 4:
elevation = float(sys.argv[4]) # elevation of start point
else:
elevation = 100 # default elevation for start point
mu = BMP180MeasureUnit()
i2c = I2CIface(None, 0x77)
fw = FileWriter(fname='bmp180.log',
filt=['elev', 'pressure', 'temp', 'datetime'])
bmp = BMP180('BMP180', mu, i2c)
bmp.LoadCalibration()
bmp.SetSealevel(elevation)
#bmp.GetTemp()
for i in range(n):
data = bmp.GetPressure()
data['elev'] = bmp.GetAltitude()
data['temp'] = bmp.GetTemp()['temp']
fw.WriteData(data)
print(data)
time.sleep(delay)
