def shape_net_test(): std_out_path = "/home/zgong8/PerceptualMetric/examples/data_out/decimation_low_{}.obj" std_out_path_ori = "/home/zgong8/PerceptualMetric/examples/data_out/decimation_low_ori_{}.obj" for i in range(10): in_path = random_shape_net_object() print(in_path) out_path = std_out_path.format(i) out_path_ori = std_out_path_ori.format(i) p = Pipeline(1) d = None while d is None: c = {} for k, f in DecimationDeformer.get_applicable_configs().items(): q = np.random.uniform() c[k] = f(q) tmp_d = DecimationDeformer(c) if tmp_d.get_score() == 1: d = tmp_d p.plug(d) p.process_shape_file(in_path, out_path) p = Pipeline(0) p.process_shape_file(in_path, out_path_ori)
def string_to_pipeline(string): each_deformation_finder = re.compile("<.*?}") deformation_strings = each_deformation_finder.findall(string) p = Pipeline(len(deformation_strings)) for deformation_string in deformation_strings: p.plug(substring_to_deformation(deformation_string)) return p
def shape_net_test(): for i in range(10): in_path = random_shape_net_object() print(in_path) out_path = os.path.join(curr_dir, data_out_dir, "arap_high_{}.obj".format(i)) out_path_ori = os.path.join(curr_dir, data_out_dir, "arap_high_{}_ori.obj".format(i)) p = Pipeline(1) d = None while d is None: c = {} for k, f in ARAPDeformer.get_applicable_configs().items(): q = np.random.uniform() c[k] = f(q) tmp_d = ARAPDeformer(c) if tmp_d.get_score() == 3: d = tmp_d p.plug(d) p.process_shape_file(in_path, out_path) p = Pipeline(0) p.process_shape_file(in_path, out_path_ori)
def string_to_pipelines(string): each_deformation_finder = re.compile("<.*?}") deformation_strings = each_deformation_finder.findall(string) pipelines = [] for deformation_string in deformation_strings: p = Pipeline(1) p.plug(substring_to_deformation(deformation_string)) pipelines.append(p) return pipelines
def random_shape_sample(): for i in range(5, 10): in_path = random_shape_net_object() out_path_ori = r"/home/zgong8/data_out/base-" + str(i) + "-ori.obj" out_path1 = r"/home/zgong8/data_out/base-" + str(i) + "-1.obj" file_path1 = r"/home/zgong8/data_out/base-" + str(i) + "-1.txt" out_path2 = r"/home/zgong8/data_out/base-" + str(i) + "-2.obj" file_path2 = r"/home/zgong8/data_out/base-" + str(i) + "-2.txt" empty_pipeline = Pipeline(0) empty_pipeline.process_shape_file(in_path, out_path_ori) deformation_level = i % 3 + 1 status = False while not status: ppl, status = run_leveled_pipeline(3, in_path, out_path1) with open(file_path1, 'w') as f: f.write(in_path) f.write("\n") f.write(str(ppl)) f.write("\n") f.write("status: ") f.write(str(status)) f.write("\n") f.write("score: ") f.write(str(ppl.estimate_deform_score())) if status: f.write("\n") f.write("manifold: ") f.write(str(is_manifold(file=out_path1))) f.write("\n") f.write("cut_at: ") f.write(str(ppl.cut_by_point_cloud)) f.close() status = False while not status: ppl, status = run_leveled_pipeline(1, in_path, out_path2) with open(file_path2, 'w') as f: f.write(in_path) f.write("\n") f.write(str(ppl)) f.write("\n") f.write("status: ") f.write(str(status)) f.write("\n") f.write("score: ") f.write(str(ppl.estimate_deform_score())) if status: f.write("\n") f.write("manifold: ") f.write(str(is_manifold(file=out_path2))) f.write("\n") f.write("cut_at: ") f.write(str(ppl.cut_by_point_cloud)) f.close() print("{} done!".format(str(i)))
def get_random_pipeline(): q = np.random.uniform() slots = int(np.floor(q * 10 + 1)) p = Pipeline(slots) while not p.is_full(): p.plug(get_random_deformation()) # p_str = str(p) # vd = p_str.find("VoxelizeDeformer") # if vd != -1: # dd = p_str.find("DecimationDeformer", vd) # if dd != -1: # p = None return p
def insurance_cross_sell_prediction(): test_json = request.get_json() if test_json: #there is data if isinstance(test_json, dict): teste_raw = pd.DataFrame(test_json, index=[0]) #unique example else: teste_raw = pd.DataFrame(test_json, columns=test_json[0].keys()) #multiple examples # Instantiate pipeline = Pipeline() # Data Cleaning df1 = pipeline.data_cleaning(teste_raw) # Feature Engineering df2 = pipeline.feature_engineering(df1) # Data Preparation df3 = pipeline.data_preparation(df2) # Prediction df_response = pipeline.predict(model, df3, teste_raw) return df_response else: return Response('{}', status=200, mimetype='application/json')
def test(): in_path = os.path.join(curr_dir, data_out_dir, "mc5b.obj") out_path = os.path.join(curr_dir, data_out_dir, "mc5b_decimation.obj") p = Pipeline(1) d = DecimationDeformer({"ratio": 5.0}) p.plug(d) p.process_shape_file(in_path, out_path)
def head_test(): in_path = os.path.join(curr_dir, data_in_dir, file_name) out_path = os.path.join(curr_dir, data_out_dir, "marching_cubes_head_test.obj") p = Pipeline(1) d = PointCloudDeformer({}) p.plug(d) p.process_shape_file(in_path, out_path)
def shape_net_test(): # in_path = random_shape_net_object() in_path = "/home/zgong8/ShapeNetCore.v2/03593526/2872c4b8e2f86201b7d0f3d89bbac230/models/model_normalized.obj" for i in range(1): print(in_path) out_path = os.path.join(curr_dir, data_out_dir, "rc_low_{}.obj".format(i)) out_path_ori = os.path.join(curr_dir, data_out_dir, "rc_low_{}_ori.obj".format(i)) p = Pipeline(1) d = None while d is None: c = { 't_x': 0.2905716521257016, 't_y': 0.4142014801845495, 't_z': 0.4329088231382898, 'theta': 0.22074621042125056, 'phi': 0.04610239008672457, 'pivots': 0.8523162841916193 } for k, f in RandomCageDeformer.get_applicable_configs().items(): q = np.random.uniform() c[k] = f(q) tmp_d = RandomCageDeformer(c) if tmp_d.get_score() == 1: d = tmp_d p.plug(d) print(p) p.process_shape_file(in_path, out_path) p = Pipeline(0) p.process_shape_file(in_path, out_path_ori)
def test(): in_path = os.path.join(curr_dir, data_out_dir, "mc5b_decimation.obj") out_path = os.path.join(curr_dir, data_out_dir, "mc5b_arap.obj") p = Pipeline(1) c = {} for k, f in ARAPDeformer.get_applicable_configs().items(): q = np.random.uniform() c[k] = f(q) d = ARAPDeformer(c) p.plug(d) p.process_shape_file(in_path, out_path)
def shape_net_test(): for i in range(10): in_path = random_shape_net_object() print(in_path) out_path = os.path.join(curr_dir, data_out_dir, "pcd{}.obj".format(i)) p = Pipeline(1) d = PointCloudDeformer({}) p.plug(d) p.process_shape_file(in_path, out_path)
def shape_net_test2(): std_out_path = "/home/zgong8/PerceptualMetric/examples/data_out/mc{}.obj" for i in range(10): in_path = random_shape_net_object() print(in_path) out_path = std_out_path.format(i) p = Pipeline(1) d = MarchingCubesDeformer({}) p.plug(d) p.process_shape_file(in_path, out_path)
def validate_pipeline(p: Pipeline, level): if level != -1: if p.estimate_deform_score() != level: return False has_decimation = False has_reformation = False has_scaling = False has_voxel = False has_sub = False for d in p._deformers: d_string = str(type(d)) if "Voxel" in d_string: if has_reformation: return False else: has_reformation = True has_voxel = True elif "Decimation" in d_string: if has_decimation: return False elif has_voxel: return False else: has_decimation = True elif "Point" in d_string or "Marching" in d_string: if has_reformation: return False else: has_reformation = True elif "Length" in d_string: if has_scaling: return False else: has_scaling = True elif "Subdivision" in d_string: if has_sub: return False else: has_sub = True return True
def test(): in_path = os.path.join(curr_dir, data_out_dir, file_name) out_path = os.path.join(curr_dir, data_out_dir, "mc5b_biharmonic.obj") p = Pipeline(1) c = { PIVOTS: np.floor(random() * 4 + 1), FIRST: random(), SECOND: random(), THIRD: random(), FOURTH: random() } d = BiharmonicDeformer(c) p.plug(d) p.process_shape_file(in_path, out_path)
def shape_net_test(): std_out_path = "/home/zgong8/PerceptualMetric/examples/data_out/bi_high_{}.obj" for i in range(10): in_path = random_shape_net_object() print(in_path) out_path = std_out_path.format(i) p = Pipeline(1) c = { PIVOTS: 1, FIRST: random(), SECOND: random(), THIRD: random(), FOURTH: random(), DIS: 1.6 } d = BiharmonicDeformer(c) p.plug(d) p.process_shape_file(in_path, out_path)
def __init__(self): self.pipeline=Pipeline()
class NeritFacade(object): def __init__(self): self.pipeline=Pipeline() def createPosTagger(self,config_file): # crear un Tagger para POS usando PostModelGenerator como ayudante postModelGenerator=PostModelGenerator(config_file) model=postModelGenerator.createModel() return model def createChunkTagger(self,config_file): # crear un Tagger entrenado segun los parametros de /config/taggers.ini utilizando ChunkerModelGenerator como clase "ayudante" config = ConfigParser.RawConfigParser() config.optionxform = str config.read(config_file) phrases=[ph for tag,ph in config.items('chunkers.phrases')] files=[fname for key,fname in config.items('chunk_training_corpus.corpus')] featureName=config.get('chunker.features','featureExtractor') chunkerGenerator=ChunkerModelGenerator(config.get('chunkers','save_to'),config.get('chunk_training_corpus','corpora'),files,phrases,config.getfloat('chunk_training_corpus','training_portion'),config.get('chunkers','ext_file'),ContextFeatureExtractor()) model=chunkerGenerator.createModel() return model def getTokenizerStage(self,tokenizers_file,abbreviations,src_field='text',dst_field='text'): # crear etapa de Tokenizacion completa y adaptar para que enchufe en el Pipe tokenizerFactory=TokenizerFactory(tokenizers_file,abbreviations) tokenizerStages=tokenizerFactory.toStage(src_field,dst_field) return tokenizerStages def getTaggerStage(self,model_path,src_field='text',dst_field='tagged',decorator=None): # crear etapa de etiquetado gramatical y adaptar para que encaje en el Pipe factory=TaggerFactory(model_path) factory.set_decorator(decorator) stage=factory.toStage(src_field,dst_field) return stage def getChunkerModelStage(self,model_path,src_field='tagged',dst_field='chunked',decorator=None): # crear etapa de reconocimiento de Chunks basada en modelo entrenado.Adaptada al pipe. factory=ModelChunkerFactory(model_path) factory.set_decorator(decorator) stage=factory.toStage(src_field,dst_field) return stage def getPersistenceStage(self,iFilter,save_to,corpus_size=-1,f_ext=".tcs",src_field='chunked',dst_field='chunked'): # Opcional: dejar como una etapa mas en el pipe por si se desea armar un corpus con la salida del pipe. factory=PersistenceFactory(save_to,f_ext,corpus_size,iFilter) stage=factory.toStage(src_field,dst_field) return stage def createPipeline(self,stage_list): # armar el pipe con todas las etapas indicadas por stage_list for s in stage_list: if isinstance(s,list): for s_i in s: self.pipeline.addStage(s_i) else: self.pipeline.addStage(s) return self.pipeline def add_finalStage(self,stages): # determinar etapa final del pipe. Recordar que el Pipe es Observador, pero tambien Subject y puede emitir notificaciones al culminar su proceso. if isinstance(stages,list): for stage in stages: self.pipeline.addFinalStage(stage) else: self.pipeline.addFinalStage(stages) def pipe(self): return self.pipeline def getDataLineConnection(self,filename): # instancias una conexion para archvios linea-por-linea return DataLineConnection(filename) def getFileConnection(self,filename): # instanciar una conexion contra archivos con formato Json return FileConnection(filename) def getTwitterConnection(self,hashtags=[],timeLine=True): # contectarme a Twitter: puedo usar hashtags o procesar el timeline return TwitterConnection(hashtags=hashtags,timeLine=timeLine) def getChunkerStrategy(self,grammar_location=locations,grammar_events=events,grammar_words=words,grammar_clean=clean): # retorna puramente una estrategia. Es más bien una prueba.... locations=PostPatternStrategy(grammar_location) #loop=3 location_words=PostPatternStrategy(grammar_words)#loop=1 locations=SequentialStrategy(locations,location_words) iobFixer=IOBFixerStrategy() locations_words_strategy=SequentialStrategy(locations,iobFixer) events=PostPatternStrategy(grammar_events) #loop=1 events=SequentialStrategy(locations_words_strategy,events) events=SequentialStrategy(events,iobFixer) return events def getChunkerDecorator(self,grammar_location=locations,grammar_events=events,grammar_words=words,grammar_clean=clean): # un decortator ( que detecta sintagmas nominales,adverbiales,etc ) y se aniade funcionalidad para detectar direcciones y eventos locations=PostPatternStrategy(grammar_location) location_words=PostPatternStrategy(grammar_words) locations=SequentialStrategy(locations,location_words) iobFixer=IOBFixerStrategy() locations_words_strategy=SequentialStrategy(locations,iobFixer) # busquemos por eventos dentro del arbol de chunks events=PostPatternStrategy(grammar_events) events=SequentialStrategy(locations_words_strategy,events) events=SequentialStrategy(events,iobFixer) # decorador decorator=WrappedStrategyTagger() decorator.set_strategy(events) return decorator def getChunkerStage(self,grammar_chunks=chunks,src_field='tagged',dst_field='chunked',decorator=None): factory=RegexpChunkerFactory(grammar_chunks) factory.set_decorator(decorator) stage=factory.toStage(src_field,dst_field) return stage def getChunkerWrappedStage(self,model_path,grammar_chunks=chunks,src_field='tagged',dst_field='chunked',strategy=None): # Me va a servir para pruebas # armar un chunker para detectar frases utilizando corpus y luego las gramáticas ( desde cero: desde sintagmas nominales,preposicionales,etc ) # arma un chunker combinando dos decorators y aplica en secuencia. factory=ModelChunkerFactory(model_path) modelChunker=factory.createInstance() factory=RegexpChunkerFactory(grammar_chunks) regexpChunker=factory.createInstance() wrappedRegexpChunker=WrappedStrategyTagger(regexpChunker) # estrategia para reconocer direcciones sobre los sintagmas estandar wrappedRegexpChunker.set_strategy(strategy) compositeTagger=CompositeWrapperTagger(modelChunker,wrappedRegexpChunker) chunkerStage=TaggerAdapter(compositeTagger,src_field,dst_field) return chunkerStage
import os from pipeline.Pipeline import Pipeline from module.deformers.VoxelizeDeformer import VoxelizeDeformer, NUM_CUBES curr_dir = os.path.dirname(os.path.realpath(__file__)) data_in_dir = "data_in" data_out_dir = "data_out" file_name = "head.obj" in_path = os.path.join(curr_dir, data_in_dir, file_name) out_path = os.path.join(curr_dir, data_out_dir, "vox_head_test_32.obj") p = Pipeline(1) d = VoxelizeDeformer({NUM_CUBES: 128}) p.plug(d) p.process_shape_file(in_path, out_path)
def run_pipeline(logging, frames, models, model_classes, models_array, model_paths, args, start_time, out, save=False): end_time = time.time() face, landmarks, pose_estimation, gaze = models logging.info("""{f} Frame(s) loading time: {t}""".format(f=len(frames), t=(end_time - start_time))) logging.info("Creating Image Frame pipeline: ") default_pipeline = Pipeline(model_type=None, model_class=None, objects={}, networks={}, objs={}, nets={}, logging=logging) # load the network objects default_pipeline.run(model_classes, models_array, model_paths, args) image_frame = ImageFrame(model_type=face, model_class=model_classes, objects=default_pipeline.objects, networks=default_pipeline.networks, objs=default_pipeline.objs, nets=default_pipeline.nets) face_detection = Face(model_type=landmarks, model_class=model_classes.tolist()[1], objects=default_pipeline.objects, networks=default_pipeline.networks, objs=default_pipeline.objs, nets=default_pipeline.nets) gaze_estimation = Gaze(model_type=gaze, model_class=model_classes.tolist()[3], objects=default_pipeline.objects, networks=default_pipeline.networks, objs=default_pipeline.objs, nets=default_pipeline.nets) start_time = time.time() image_frame.run(args, frames, model_classes) logging.info("""Preprocess and exec async for face detection: {t}""".format(t=(time.time() - start_time))) # for each n batches and for each batch_size start_time = time.time() gen_frames, faces, face_boxes = \ image_frame.produce(args, frames, model_classes) logging.info("""Post-process face detection: {t}""".format(t=(time.time() - start_time))) start_time = time.time() face_detection.run(args, frames, faces, model_classes) logging.info("""Preprocess and exec async for facial landmarks: {t}""".format(t=(time.time() - start_time))) start_time = time.time() batch_gen_frames, cropped_left, \ cropped_right, left_eye, right_eye, \ nose, left_lip, right_lip = \ face_detection.produce(args, frames, gen_frames, faces, face_boxes, model_classes) logging.info("""Post-process facial landmarks: {t}""".format(t=(time.time() - start_time))) start_time = time.time() pose_model = Pose(model_type=pose_estimation, model_class=model_classes.tolist()[2], objects=default_pipeline.objects, networks=default_pipeline.networks, objs=default_pipeline.objs, nets=default_pipeline.nets) pose_model.run(args, frames, faces, model_classes) logging.info("""Preprocess and exec async head pose: {t}""".format(t=(time.time() - start_time))) start_time = time.time() head_pose_angles = pose_model.produce(args, frames, batch_gen_frames, model_classes) logging.info("""Post-process head pose: {t}""".format(t=(time.time() - start_time))) gen_frames = None start_time = time.time() # preprocessing the gaze and executing the landmarks detection gaze_estimation.run(args, frames, faces, cropped_left, cropped_right, head_pose_angles, model_classes) logging.info("""Preprocess and exec async gaze estimation: {t}""".format(t=(time.time() - start_time))) faces = None start_time = time.time() # post process gaze vector gaze_vector = gaze_estimation.produce(args, frames, batch_gen_frames, model_classes) logging.info("""Post-process gaze: {t}""".format(t=(time.time() - start_time))) start_time = time.time() ext = os.path.splitext(args.output_path)[1] if ext in is_video(): default_pipeline.finalize_pipeline(out, frames, args, batch_gen_frames, face_boxes, left_eye, right_eye, nose, left_lip, right_lip, gaze_vector, save=save) else: frame = default_pipeline.write_pipeline(0, frames, batch_gen_frames, face_boxes, left_eye, right_eye, nose, left_lip, right_lip, gaze_vector) cv2.imwrite(out, frame) logging.info("""Post-process video writing and painting time: {t}""".format(t=(time.time() - start_time))) return batch_gen_frames
def test(): std_out_path = "/home/zgong8/PerceptualMetric/examples/data_out/decimation_sub_{}.obj" std_out_path_ori = "/home/zgong8/PerceptualMetric/examples/data_out/decimation_sub_{}_ori.obj" for i in range(10): in_path = random_shape_net_object() print(in_path) out_path = std_out_path.format(i) out_path_ori = std_out_path_ori.format(i) p = Pipeline(2) d = DecimationDeformer({"ratio": 3.0}) p.plug(d) df = SubdivisionDeformer({STEPS: 1}) p.plug(df) p.process_shape_file(in_path, out_path) p = Pipeline(0) p.process_shape_file(in_path, out_path_ori)
def __init__(self): self.pipeline = Pipeline()
class NeritFacade(object): def __init__(self): self.pipeline = Pipeline() def createPosTagger(self, config_file): # crear un Tagger para POS usando PostModelGenerator como ayudante postModelGenerator = PostModelGenerator(config_file) model = postModelGenerator.createModel() return model def createChunkTagger(self, config_file): # crear un Tagger entrenado segun los parametros de /config/taggers.ini utilizando ChunkerModelGenerator como clase "ayudante" config = ConfigParser.RawConfigParser() config.optionxform = str config.read(config_file) phrases = [ph for tag, ph in config.items('chunkers.phrases')] files = [ fname for key, fname in config.items('chunk_training_corpus.corpus') ] featureName = config.get('chunker.features', 'featureExtractor') chunkerGenerator = ChunkerModelGenerator( config.get('chunkers', 'save_to'), config.get('chunk_training_corpus', 'corpora'), files, phrases, config.getfloat('chunk_training_corpus', 'training_portion'), config.get('chunkers', 'ext_file'), ContextFeatureExtractor()) model = chunkerGenerator.createModel() return model def getTokenizerStage(self, tokenizers_file, abbreviations, src_field='text', dst_field='text'): # crear etapa de Tokenizacion completa y adaptar para que enchufe en el Pipe tokenizerFactory = TokenizerFactory(tokenizers_file, abbreviations) tokenizerStages = tokenizerFactory.toStage(src_field, dst_field) return tokenizerStages def getTaggerStage(self, model_path, src_field='text', dst_field='tagged', decorator=None): # crear etapa de etiquetado gramatical y adaptar para que encaje en el Pipe factory = TaggerFactory(model_path) factory.set_decorator(decorator) stage = factory.toStage(src_field, dst_field) return stage def getChunkerModelStage(self, model_path, src_field='tagged', dst_field='chunked', decorator=None): # crear etapa de reconocimiento de Chunks basada en modelo entrenado.Adaptada al pipe. factory = ModelChunkerFactory(model_path) factory.set_decorator(decorator) stage = factory.toStage(src_field, dst_field) return stage def getPersistenceStage(self, iFilter, save_to, corpus_size=-1, f_ext=".tcs", src_field='chunked', dst_field='chunked'): # Opcional: dejar como una etapa mas en el pipe por si se desea armar un corpus con la salida del pipe. factory = PersistenceFactory(save_to, f_ext, corpus_size, iFilter) stage = factory.toStage(src_field, dst_field) return stage def createPipeline(self, stage_list): # armar el pipe con todas las etapas indicadas por stage_list for s in stage_list: if isinstance(s, list): for s_i in s: self.pipeline.addStage(s_i) else: self.pipeline.addStage(s) return self.pipeline def add_finalStage(self, stages): # determinar etapa final del pipe. Recordar que el Pipe es Observador, pero tambien Subject y puede emitir notificaciones al culminar su proceso. if isinstance(stages, list): for stage in stages: self.pipeline.addFinalStage(stage) else: self.pipeline.addFinalStage(stages) def pipe(self): return self.pipeline def getDataLineConnection(self, filename): # instancias una conexion para archvios linea-por-linea return DataLineConnection(filename) def getFileConnection(self, filename): # instanciar una conexion contra archivos con formato Json return FileConnection(filename) def getTwitterConnection(self, hashtags=[], timeLine=True): # contectarme a Twitter: puedo usar hashtags o procesar el timeline return TwitterConnection(hashtags=hashtags, timeLine=timeLine) def getChunkerStrategy(self, grammar_location=locations, grammar_events=events, grammar_words=words, grammar_clean=clean): # retorna puramente una estrategia. Es más bien una prueba.... locations = PostPatternStrategy(grammar_location) #loop=3 location_words = PostPatternStrategy(grammar_words) #loop=1 locations = SequentialStrategy(locations, location_words) iobFixer = IOBFixerStrategy() locations_words_strategy = SequentialStrategy(locations, iobFixer) events = PostPatternStrategy(grammar_events) #loop=1 events = SequentialStrategy(locations_words_strategy, events) events = SequentialStrategy(events, iobFixer) return events def getChunkerDecorator(self, grammar_location=locations, grammar_events=events, grammar_words=words, grammar_clean=clean): # un decortator ( que detecta sintagmas nominales,adverbiales,etc ) y se aniade funcionalidad para detectar direcciones y eventos locations = PostPatternStrategy(grammar_location) location_words = PostPatternStrategy(grammar_words) locations = SequentialStrategy(locations, location_words) iobFixer = IOBFixerStrategy() locations_words_strategy = SequentialStrategy(locations, iobFixer) # busquemos por eventos dentro del arbol de chunks events = PostPatternStrategy(grammar_events) events = SequentialStrategy(locations_words_strategy, events) events = SequentialStrategy(events, iobFixer) # decorador decorator = WrappedStrategyTagger() decorator.set_strategy(events) return decorator def getChunkerStage(self, grammar_chunks=chunks, src_field='tagged', dst_field='chunked', decorator=None): factory = RegexpChunkerFactory(grammar_chunks) factory.set_decorator(decorator) stage = factory.toStage(src_field, dst_field) return stage def getChunkerWrappedStage(self, model_path, grammar_chunks=chunks, src_field='tagged', dst_field='chunked', strategy=None): # Me va a servir para pruebas # armar un chunker para detectar frases utilizando corpus y luego las gramáticas ( desde cero: desde sintagmas nominales,preposicionales,etc ) # arma un chunker combinando dos decorators y aplica en secuencia. factory = ModelChunkerFactory(model_path) modelChunker = factory.createInstance() factory = RegexpChunkerFactory(grammar_chunks) regexpChunker = factory.createInstance() wrappedRegexpChunker = WrappedStrategyTagger(regexpChunker) # estrategia para reconocer direcciones sobre los sintagmas estandar wrappedRegexpChunker.set_strategy(strategy) compositeTagger = CompositeWrapperTagger(modelChunker, wrappedRegexpChunker) chunkerStage = TaggerAdapter(compositeTagger, src_field, dst_field) return chunkerStage
def shape_net_test(): std_out_path1 = "/home/zgong8/PerceptualMetric/examples/data_out/sd1_{}.obj" std_out_path2 = "/home/zgong8/PerceptualMetric/examples/data_out/sd2_{}.obj" std_out_path3 = "/home/zgong8/PerceptualMetric/examples/data_out/sd3_{}.obj" for i in range(10): in_path = random_shape_net_object() print(in_path) out_path1 = std_out_path1.format(i) out_path2 = std_out_path2.format(i) out_path3 = std_out_path3.format(i) p = Pipeline(1) df = SubdivisionDeformer({STEPS: 1}) p.plug(df) p.process_shape_file(in_path, out_path1) p = Pipeline(1) df = SubdivisionDeformer({STEPS: 2}) p.plug(df) p.process_shape_file(in_path, out_path2) p = Pipeline(1) df = SubdivisionDeformer({STEPS: 3}) p.plug(df) p.process_shape_file(in_path, out_path3)