def device_info(self):
"""
This function returns information about connected WFS instruments.
"""
count = self.device_count()
sensors = []
for list_index in range(count):
device_id = ViInt32()
in_use = ViInt32()
instrument_name = ViChar256()
instrument_sn = ViChar256()
resource_name = ViRsrc()
WfsLib.result(
self._dll.WFS_GetInstrumentListInfo(VI_NULL(), list_index,
byref(device_id),
byref(in_use),
instrument_name,
instrument_sn,
resource_name))
log.info(f"WFS device_id: {device_id.value}")
log.info(f"in use: {in_use.value}")
log.info(f"instrument_name: {instrument_name.value}")
log.info(f"instrument_sn: {instrument_sn.value}")
log.info(f"resource_name: {resource_name.value}")
sensors.append([
device_id.value, in_use.value, instrument_name.value,
instrument_sn.value, resource_name.value
])
return sensors
def get_mla_info(self):
"""
This functions lists all available microlens arrays.
"""
mlas = []
for mla_index in range(self.get_mla_count()):
mla_name = ViChar256()
cam_pitch = ViReal64()
lenslet_pitch = ViReal64()
spot_offset = [ViReal64(), ViReal64()]
lenslet_f = ViReal64()
grd_corr_0 = ViReal64()
grd_corr_45 = ViReal64()
WfsLib.result(
self._dll.WFS_GetMlaData(self._handle, mla_index, mla_name,
byref(cam_pitch),
byref(lenslet_pitch),
byref(spot_offset[0]),
byref(spot_offset[1]),
byref(lenslet_f), byref(grd_corr_0),
byref(grd_corr_45)))
log.info(f"MLA name: {mla_name.value}")
mlas.append([
mla_name.value, cam_pitch.value, lenslet_pitch.value,
spot_offset[0].value, spot_offset[1].value, lenslet_f.value,
grd_corr_0.value, grd_corr_45
])
return mlas
def obtener_nombre_alumno(archivo, sw):
log.info("NOMBRE_ALUMNO | Obteniendo nombre del alumno ...")
nombre_alumno.extend(obtener_nombre_y_apellido_del_alumno(archivo, sw))
if nombre_alumno:
log.info("NOMBRE_ALUMNO | Alumno que realizo el ensayo: " + nombre_alumno[0])
else:
log.warning("NOMBRE_ALUMNO | No se encontro el nombre del alumno")
def get_mla_count(self):
"""
This function returns the number of calibrated Microlens Arrays
"""
mla_count = ViInt32()
WfsLib.result(self._dll.WFS_GetMlaCount(self._handle,
byref(mla_count)))
log.info(
f"WFS_GetMlaCount: {mla_count.value} available microlens arrays")
return mla_count.value
def define_indexes():
log.info('defining indexes')
db.wipo.create_index('field_id')
db.wipo.create_index('patent_id')
db.uspatentcitation.create_index('patent_id')
db.uspatentcitation.create_index('citation_id')
db.patent.create_index('id')
db.patent.create_index('date')
# db.series.create_index('node')
# db.series.create_index('date')
# db.series.create_index('measure')
log.info('indexes defined!')
def get_status(self):
"""
This function returns the device status of the Wavefront Sensor instrument.
"""
device_status = ViInt32()
log.spam(f"querying device status")
WfsLib.result(
self._dll.WFS_GetStatus(self._handle, byref(device_status)))
log.info(f"WFS_GetStatus: {device_status.value}")
# check all status bits
status = {}
for key in WFS_STATUS:
if WFS_STATUS[key] & device_status.value:
status[key] = True
else:
status[key] = False
return status
def obtener_tema_del_texto(archivo_test, sw, cantidad_de_topicos):
log.info("TOPICOS | Obteniendo topicos del texto ...")
log.debug("TOPICOS | Preparando archivos para modelo LDA ...")
nlp = spacy.load('es_core_news_sm')
hilos_preparar_archivos_para_lda = list()
for archivo in archivos_entrenamiento_limpios:
hilo_preparar_archivo_para_lda = threading.Thread(
target=preparar_archivo_entrenamiento_para_lda,
args=(
archivo.texto,
nlp,
sw,
))
hilos_preparar_archivos_para_lda.append(hilo_preparar_archivo_para_lda)
hilo_preparar_archivo_para_lda.start()
texto_preparado_test = preparar_texto_para_lda(archivo_test, nlp, sw)
for index, thread in enumerate(hilos_preparar_archivos_para_lda):
thread.join()
log.debug("TOPICOS | Archivos de entrenamiento preparados")
log.debug(
"TOPICOS | Corriendo algoritmo LDA para archivos de entrenamiento ...")
diccionario = corpora.Dictionary(textos_preparados_entrenamiento)
corpus = [
diccionario.doc2bow(texto) for texto in textos_preparados_entrenamiento
]
modelo_lda = gensim.models.LdaMulticore(corpus,
num_topics=10,
id2word=diccionario,
passes=2)
log.debug(
"TOPICOS | Algoritmo LDA para archivos de entrenamiento finalizado")
log.debug("TOPICOS | Corriendo algoritmo LDA para archivos de test ...")
indice, score = sorted(
modelo_lda[diccionario.doc2bow(texto_preparado_test)],
key=lambda tup: -1 * tup[1])[0]
topico_con_mas_score.extend([
palabra.split("*")[1].replace("\"", "") for palabra in
modelo_lda.print_topic(indice, cantidad_de_topicos).split(" + ")
])
log.info(f"TOPICOS | Topicos del texto: {topico_con_mas_score}")
def obtener_plagio_de_internet(texto_archivo_test_limpio, sw, cantidad_de_links, buscar_en_pdfs):
log.info("PLAGIO_DE_INTERNET | Obteniendo plagio de paginas de internet...")
hilos_plagio_de_internet = list()
for oracion in texto_archivo_test_limpio:
oracion_preparada = preparar_oracion(oracion, sw)
if oracion_preparada is None:
continue
hilo_plagio_de_internet = threading.Thread(target=obtener_oracion_mas_parecida_de_internet,
args=(oracion, oracion_preparada, sw, cantidad_de_links, buscar_en_pdfs,))
hilos_plagio_de_internet.append(hilo_plagio_de_internet)
hilo_plagio_de_internet.start()
for index, thread in enumerate(hilos_plagio_de_internet):
thread.join()
plagio_de_internet.extend([(oracion, posible_plagio, porcentaje, archivo, ubicacion) for
(oracion, posible_plagio, porcentaje, archivo, ubicacion) in porcentajes_de_aparicion_internet if
(porcentaje > 0.7)])
log.info(f"PLAGIO_DE_INTERNET | {len(plagio_de_internet)} plagios de paginas de internet encontrados")
def insert_file(file_path, strip_fields=[], decode_field=[]):
log.info("inserting " + file_path)
# insert everything as string! We don't need any numberic queries!
df = pd.read_csv(file_path, sep='\t',iterator=True, chunksize=5000, dtype='str')
collection = os.path.basename(file_path).split('.')[0]
collection = db.get_collection(collection)
for f in df:
for field in strip_fields:
try:
f[field] = pd.core.strings.str_strip(f[field])
except:
# I'm a scatman :)
pass
for field in decode_field:
try:
f[field] = f[field].str.decode('unicode-escape').str.encode('utf8')
except:
# I'm a scatman :)
pass
collection.insert_many(f.to_dict('records'))
def obtener_plagio_de_otros_tps(texto_archivo_test_limpio, sw):
log.info("PLAGIO_DE_TPS | Obteniendo plagio de otros tps...")
hilos_plagio_de_otros_tps = list()
for oracion in texto_archivo_test_limpio:
oracion_preparada = preparar_oracion(oracion, sw)
if oracion_preparada is None:
continue
archivos_entrenamiento = archivos_entrenamiento_limpios
hilo_plagio_de_otros_tps = threading.Thread(target=obtener_oracion_mas_parecida_del_dataset,
args=(oracion, oracion_preparada, texto_archivo_test_limpio, archivos_entrenamiento, sw,))
hilos_plagio_de_otros_tps.append(hilo_plagio_de_otros_tps)
hilo_plagio_de_otros_tps.start()
for index, thread in enumerate(hilos_plagio_de_otros_tps):
thread.join()
plagio_de_otros_tps.extend([(oracion, posible_plagio, porcentaje, archivo, ubicacion) for
(oracion, posible_plagio, porcentaje, archivo, ubicacion) in porcentajes_de_aparicion_otros_tps if
(porcentaje > 0.7)])
log.info(f"PLAGIO_DE_TPS | {len(plagio_de_otros_tps)} plagios de otros tps encontrados")
def inversion():
f = forward.forward_gpu()
real_geo_model = forward.geoelectric_model()
real_geo_model.load_from_file('../test_data/test_geo_model.json')
coef = forward.filter_coefficient()
coef.load_cos_coef('../test_data/cos_xs.txt')
coef.load_hkl_coef('../test_data/hankel1.txt')
time = forward.forward_data()
time.generate_time_stamp_by_count(-5, -2, 20)
f.load_general_params(10, 100, 50)
f.load_filter_coef(coef)
f.load_geo_model(real_geo_model)
f.load_time_stamp(time)
f.forward()
real_response = f.get_result_magnetic()
real_response.name = real_geo_model.name
# helper.add_noise(m, 0.05)
real_response_m = real_response['response']
inversion_geo_model = forward.isometric_model()
inversion_geo_model.resize(20)
inversion_geo_model.height = 10
inversion_geo_model.name = 'inversion'
inv = Inversion(inversion_geo_model, f)
inv.set_initial_geo_model(npy.ones([inversion_geo_model.count]) * 50.0)
inv.set_target_magnetic(real_response_m)
for i in range(500):
log.info('iteration %d ' % i)
inv.rand_grad()
inv.update_model()
inv.update_step()
log.info('iteration %d, loss = %f' % (i, inv.loss()))
if i % 10 == 0:
inversion_geo_model.set_item_s('resistivity',
inv.geo_model.tolist())
inversion_geo_model.name = 'Inversion'
f.load_geo_model(forward.iso_to_geo(inversion_geo_model))
f.forward()
inversion_response = f.get_result_magnetic()
inversion_response.name = 'Inversion'
fig = helper.draw_resistivity(
real_geo_model,
forward.iso_to_geo(inversion_geo_model),
last_height=240)
fig.show()
fig = helper.draw_forward_result(real_response, inversion_response)
fig.show()
print('loss = %f' % helper.loss(real_response, inversion_response))
pass
pass