├── .gitignore ├── README.md ├── projects └── kaggle │ └── usp │ ├── dataset-metadata.json │ ├── input │ ├── jupyter │ ├── ana.ipynb │ ├── debug.ipynb │ ├── ensemble.ipynb │ ├── pppm-deberta-v3-large-baseline-w-w-b-train.ipynb │ ├── pppm-deberta-v3-large-baseline-w-w-b-train.py │ ├── prepare.ipynb │ ├── stacking.ipynb │ └── stacking2.ipynb │ ├── prepare │ └── gen-records.py │ ├── src │ ├── config.py │ ├── dataset-metadata.json │ ├── dataset.py │ ├── ensemble │ ├── ensemble.py │ ├── ensemble_conf.py │ ├── eval.py │ ├── flags │ │ ├── base │ │ ├── best │ │ └── best2 │ ├── infer.py │ ├── main.py │ ├── mlm-main.py │ ├── postprocess.py │ ├── preprocess.py │ ├── stacking.py │ ├── tf │ │ ├── loss.py │ │ └── model.py │ ├── torch │ │ ├── dataset.py │ │ ├── loss.py │ │ └── model.py │ ├── util.py │ └── wandb │ │ └── debug-cli.log │ └── working ├── third ├── GraphEmbedding │ ├── LICENSE │ ├── README.md │ ├── data │ │ └── flight │ │ │ ├── brazil-airports.edgelist │ │ │ ├── europe-airports.edgelist │ │ │ └── usa-airports.edgelist │ ├── examples │ │ ├── alias.py │ │ ├── deepwalk_wiki.py │ │ ├── line_wiki.py │ │ ├── node2vec_flight.py │ │ ├── node2vec_wiki.py │ │ ├── sdne_wiki.py │ │ └── struc2vec_flight.py │ ├── ez_setup.py │ ├── ge │ │ ├── __init__.py │ │ ├── alias.py │ │ ├── classify.py │ │ ├── models │ │ │ ├── __init__.py │ │ │ ├── deepwalk.py │ │ │ ├── line.py │ │ │ ├── node2vec.py │ │ │ ├── sdne.py │ │ │ └── struc2vec.py │ │ ├── utils.py │ │ └── walker.py │ ├── ge2 │ │ ├── __init__.py │ │ ├── alias.py │ │ ├── classify.py │ │ ├── models │ │ │ ├── __init__.py │ │ │ ├── deepwalk.py │ │ │ ├── line.py │ │ │ ├── node2vec.py │ │ │ ├── sdne.py │ │ │ └── struc2vec.py │ │ ├── utils.py │ │ └── walker.py │ ├── pics │ │ ├── code.png │ │ ├── deepctrbot.png │ │ ├── edge_list.png │ │ └── weichennote.png │ └── setup.py ├── README.md ├── __init__.py ├── bert │ ├── CONTRIBUTING.md │ ├── LICENSE │ ├── README.md │ ├── __init__.py │ ├── create_pretraining_data.py │ ├── extract_features.py │ ├── modeling.py │ ├── modeling_test.py │ ├── multilingual.md │ ├── optimization.py │ ├── optimization_test.py │ ├── run-char.sh │ ├── run_classifier.py │ ├── run_pretraining.py │ ├── run_squad.py │ ├── tokenization.py │ └── tokenization_test.py ├── cocolm │ ├── configuration_cocolm.py │ ├── convert_state_dict.py │ ├── modeling_cocolm.py │ ├── tokenization_cocolm.py │ └── tokenization_utils.py ├── efficientnet │ ├── __init__.py │ ├── __version__.py │ ├── keras.py │ ├── model.py │ ├── preprocessing.py │ ├── tfkeras.py │ └── weights.py ├── fast_soft_sort │ ├── __init__.py │ ├── jax_ops.py │ ├── numpy_ops.py │ ├── pytorch_ops.py │ ├── tf_ops.py │ └── third_party │ │ ├── LICENSE │ │ ├── __init__.py │ │ └── isotonic.py ├── focal_loss │ ├── __init__.py │ ├── _binary_focal_loss.py │ ├── _categorical_focal_loss.py │ ├── tests │ │ ├── __init__.py │ │ ├── test_binary_focal_loss.py │ │ ├── test_sparse_categorical_focal_loss.py │ │ └── utils.py │ └── utils │ │ ├── __init__.py │ │ ├── tests │ │ ├── __init__.py │ │ └── test_validation.py │ │ └── validation.py ├── global_objectives │ ├── README.md │ ├── __init__.py │ ├── loss_layers.py │ ├── loss_layers_example.py │ ├── loss_layers_test.py │ ├── test_all.py │ ├── util.py │ └── util_test.py ├── glove │ ├── LICENSE │ ├── Makefile │ ├── README.md │ ├── demo.sh │ ├── eval │ │ ├── matlab │ │ │ ├── WordLookup.m │ │ │ ├── evaluate_vectors.m │ │ │ └── read_and_evaluate.m │ │ ├── octave │ │ │ ├── WordLookup_octave.m │ │ │ ├── evaluate_vectors_octave.m │ │ │ └── read_and_evaluate_octave.m │ │ └── python │ │ │ ├── distance.py │ │ │ ├── evaluate.py │ │ │ └── word_analogy.py │ ├── randomization.test.sh │ └── src │ │ ├── README.md │ │ ├── common.c │ │ ├── common.h │ │ ├── cooccur.c │ │ ├── glove.c │ │ ├── shuffle.c │ │ └── vocab_count.c ├── image_segmentation_losses │ ├── README.md │ └── losses │ │ ├── binary_losses.py │ │ └── multiclass_losses.py ├── keras_applications │ ├── __init__.py │ ├── densenet.py │ ├── imagenet_utils.py │ ├── inception_resnet_v2.py │ ├── inception_v3.py │ ├── mobilenet.py │ ├── mobilenet_v2.py │ ├── nasnet.py │ ├── resnet.py │ ├── resnet50.py │ ├── resnet_common.py │ ├── resnet_v2.py │ ├── resnext.py │ ├── vgg16.py │ ├── vgg19.py │ └── xception.py ├── official │ ├── Dockerfile.cpu │ ├── Dockerfile.gpu │ ├── LICENSE │ ├── README.md │ ├── __init__.py │ ├── benchmark │ │ ├── __init__.py │ │ ├── benchmark_uploader.py │ │ ├── benchmark_uploader_main.py │ │ ├── benchmark_uploader_test.py │ │ ├── bert_benchmark.py │ │ ├── bert_benchmark_utils.py │ │ ├── bert_squad_benchmark.py │ │ ├── datastore │ │ │ └── schema │ │ │ │ ├── benchmark_metric.json │ │ │ │ ├── benchmark_run.json │ │ │ │ └── benchmark_run_status.json │ │ ├── keras_benchmark.py │ │ ├── keras_cifar_benchmark.py │ │ ├── keras_imagenet_benchmark.py │ │ ├── models │ │ │ ├── __init__.py │ │ │ └── trivial_model.py │ │ └── squad_evaluate_v1_1.py │ ├── mnist │ │ ├── README.md │ │ ├── __init__.py │ │ ├── dataset.py │ │ ├── example3.png │ │ ├── example5.png │ │ ├── mnist.py │ │ ├── mnist_eager.py │ │ ├── mnist_eager_test.py │ │ ├── mnist_test.py │ │ └── mnist_tpu.py │ ├── modeling │ │ ├── __init__.py │ │ ├── hyperparams │ │ │ ├── __init__.py │ │ │ ├── params_dict.py │ │ │ └── params_dict_test.py │ │ ├── model_training_utils.py │ │ └── tf_utils.py │ ├── nlp │ │ ├── README.md │ │ ├── __init__.py │ │ ├── bert │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── classifier_data_lib.py │ │ │ ├── common_flags.py │ │ │ ├── create_finetuning_data.py │ │ │ ├── input_pipeline.py │ │ │ ├── model_saving_utils.py │ │ │ ├── run_classifier.py │ │ │ ├── run_pretraining.py │ │ │ ├── run_squad.py │ │ │ ├── squad_lib.py │ │ │ ├── tf1_to_keras_checkpoint_converter.py │ │ │ ├── tf2_checkpoint_converter.py │ │ │ ├── tokenization.py │ │ │ └── tokenization_test.py │ │ ├── bert_modeling.py │ │ ├── bert_models.py │ │ ├── optimization.py │ │ ├── xlnet │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── classifier_utils.py │ │ │ ├── common_flags.py │ │ │ ├── data_utils.py │ │ │ ├── optimization.py │ │ │ ├── preprocess_classification_data.py │ │ │ ├── preprocess_pretrain_data.py │ │ │ ├── preprocess_squad_data.py │ │ │ ├── preprocess_utils.py │ │ │ ├── run_classifier.py │ │ │ ├── run_pretrain.py │ │ │ ├── run_squad.py │ │ │ ├── squad_utils.py │ │ │ └── training_utils.py │ │ ├── xlnet_config.py │ │ ├── xlnet_modeling.py │ │ └── xlnet_modeling_test.py │ ├── r1 │ │ ├── __init__.py │ │ ├── boosted_trees │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── data_download.py │ │ │ ├── train_higgs.py │ │ │ └── train_higgs_test.py │ │ ├── resnet │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── cifar10_download_and_extract.py │ │ │ ├── cifar10_main.py │ │ │ ├── cifar10_test.py │ │ │ ├── estimator_benchmark.py │ │ │ ├── imagenet_main.py │ │ │ ├── imagenet_preprocessing.py │ │ │ ├── imagenet_test.py │ │ │ ├── layer_test.py │ │ │ ├── resnet_model.py │ │ │ └── resnet_run_loop.py │ │ ├── utils │ │ │ ├── __init__.py │ │ │ ├── data │ │ │ │ ├── __init__.py │ │ │ │ ├── file_io.py │ │ │ │ └── file_io_test.py │ │ │ ├── export.py │ │ │ └── export_test.py │ │ └── wide_deep │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── census_dataset.py │ │ │ ├── census_main.py │ │ │ ├── census_test.py │ │ │ ├── movielens_dataset.py │ │ │ ├── movielens_main.py │ │ │ ├── movielens_test.py │ │ │ └── wide_deep_run_loop.py │ ├── recommendation │ │ ├── README.md │ │ ├── __init__.py │ │ ├── constants.py │ │ ├── create_ncf_data.py │ │ ├── data_pipeline.py │ │ ├── data_preprocessing.py │ │ ├── data_test.py │ │ ├── movielens.py │ │ ├── ncf_common.py │ │ ├── ncf_estimator_main.py │ │ ├── ncf_input_pipeline.py │ │ ├── ncf_keras_benchmark.py │ │ ├── ncf_keras_main.py │ │ ├── ncf_test.py │ │ ├── neumf_model.py │ │ ├── popen_helper.py │ │ ├── run.sh │ │ ├── run_tpu.sh │ │ └── stat_utils.py │ ├── resnet │ │ ├── README.md │ │ ├── __init__.py │ │ └── ctl │ │ │ ├── __init__.py │ │ │ ├── ctl_common.py │ │ │ ├── ctl_imagenet_benchmark.py │ │ │ ├── ctl_imagenet_main.py │ │ │ └── ctl_imagenet_test.py │ ├── staging │ │ ├── __init__.py │ │ └── shakespeare │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── shakespeare_benchmark.py │ │ │ └── shakespeare_main.py │ ├── transformer │ │ ├── README.md │ │ ├── __init__.py │ │ ├── compute_bleu.py │ │ ├── compute_bleu_test.py │ │ ├── data_download.py │ │ ├── model │ │ │ ├── __init__.py │ │ │ ├── attention_layer.py │ │ │ ├── beam_search.py │ │ │ ├── beam_search_test.py │ │ │ ├── embedding_layer.py │ │ │ ├── ffn_layer.py │ │ │ ├── model_params.py │ │ │ ├── model_utils.py │ │ │ ├── model_utils_test.py │ │ │ └── transformer.py │ │ ├── transformer_estimator_benchmark.py │ │ ├── transformer_main.py │ │ ├── translate.py │ │ ├── utils │ │ │ ├── __init__.py │ │ │ ├── dataset.py │ │ │ ├── metrics.py │ │ │ ├── schedule.py │ │ │ ├── schedule_test.py │ │ │ ├── tokenizer.py │ │ │ └── tokenizer_test.py │ │ └── v2 │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── attention_layer.py │ │ │ ├── beam_search.py │ │ │ ├── data_pipeline.py │ │ │ ├── embedding_layer.py │ │ │ ├── ffn_layer.py │ │ │ ├── metrics.py │ │ │ ├── misc.py │ │ │ ├── optimizer.py │ │ │ ├── transformer.py │ │ │ ├── transformer_benchmark.py │ │ │ ├── transformer_layers_test.py │ │ │ ├── transformer_main.py │ │ │ ├── transformer_main_test.py │ │ │ ├── transformer_test.py │ │ │ └── translate.py │ ├── utils │ │ ├── __init__.py │ │ ├── accelerator │ │ │ ├── __init__.py │ │ │ ├── tpu.py │ │ │ └── tpu_test.py │ │ ├── flags │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── _base.py │ │ │ ├── _benchmark.py │ │ │ ├── _conventions.py │ │ │ ├── _device.py │ │ │ ├── _distribution.py │ │ │ ├── _misc.py │ │ │ ├── _performance.py │ │ │ ├── core.py │ │ │ ├── flags_test.py │ │ │ └── guidelines.md │ │ ├── logs │ │ │ ├── __init__.py │ │ │ ├── cloud_lib.py │ │ │ ├── cloud_lib_test.py │ │ │ ├── guidelines.md │ │ │ ├── hooks.py │ │ │ ├── hooks_helper.py │ │ │ ├── hooks_helper_test.py │ │ │ ├── hooks_test.py │ │ │ ├── logger.py │ │ │ ├── logger_test.py │ │ │ ├── metric_hook.py │ │ │ ├── metric_hook_test.py │ │ │ └── mlperf_helper.py │ │ ├── misc │ │ │ ├── __init__.py │ │ │ ├── callstack_sampler.py │ │ │ ├── distribution_utils.py │ │ │ ├── distribution_utils_test.py │ │ │ ├── keras_utils.py │ │ │ ├── model_helpers.py │ │ │ ├── model_helpers_test.py │ │ │ └── tpu_lib.py │ │ └── testing │ │ │ ├── __init__.py │ │ │ ├── integration.py │ │ │ ├── mock_lib.py │ │ │ ├── perfzero_benchmark.py │ │ │ ├── pylint.rcfile │ │ │ ├── reference_data.py │ │ │ ├── reference_data │ │ │ ├── reference_data_test │ │ │ │ ├── dense │ │ │ │ │ ├── expected_graph │ │ │ │ │ ├── results.json │ │ │ │ │ └── tf_version.json │ │ │ │ └── uniform_random │ │ │ │ │ ├── expected_graph │ │ │ │ │ ├── results.json │ │ │ │ │ └── tf_version.json │ │ │ └── resnet │ │ │ │ ├── batch-size-32_bottleneck_projection_version-1_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_bottleneck_projection_version-2_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_bottleneck_version-1_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_bottleneck_version-2_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_building_projection_version-1_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_building_projection_version-2_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_building_version-1_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ ├── batch-size-32_building_version-2_width-8_channels-4 │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ │ └── batch_norm │ │ │ │ ├── expected_graph │ │ │ │ ├── results.json │ │ │ │ └── tf_version.json │ │ │ ├── reference_data_test.py │ │ │ └── scripts │ │ │ ├── builds_common.sh │ │ │ ├── ci_sanity.sh │ │ │ └── presubmit.sh │ └── vision │ │ ├── __init__.py │ │ └── image_classification │ │ ├── README.md │ │ ├── __init__.py │ │ ├── cifar_preprocessing.py │ │ ├── common.py │ │ ├── common_test.py │ │ ├── imagenet_preprocessing.py │ │ ├── resnet_cifar_main.py │ │ ├── resnet_cifar_model.py │ │ ├── resnet_cifar_test.py │ │ ├── resnet_imagenet_main.py │ │ ├── resnet_imagenet_test.py │ │ └── resnet_model.py ├── orbit │ ├── LICENSE │ ├── README.md │ ├── __init__.py │ ├── controller.py │ ├── controller_test.py │ ├── runner.py │ ├── standard_runner.py │ ├── standard_runner_test.py │ └── utils │ │ ├── __init__.py │ │ ├── common.py │ │ ├── common_test.py │ │ ├── epoch_helper.py │ │ ├── loop_fns.py │ │ ├── summary_manager.py │ │ ├── tpu_summaries.py │ │ └── tpu_summaries_test.py ├── reco_utils │ ├── README.md │ ├── __init__.py │ ├── azureml │ │ ├── __init__.py │ │ ├── aks_utils.py │ │ ├── azureml_designer_modules │ │ │ ├── entries │ │ │ │ ├── map_entry.py │ │ │ │ ├── ndcg_entry.py │ │ │ │ ├── precision_at_k_entry.py │ │ │ │ ├── recall_at_k_entry.py │ │ │ │ ├── score_sar_entry.py │ │ │ │ ├── stratified_splitter_entry.py │ │ │ │ └── train_sar_entry.py │ │ │ └── module_specs │ │ │ │ ├── map.yaml │ │ │ │ ├── ndcg.yaml │ │ │ │ ├── precision_at_k.yaml │ │ │ │ ├── recall_at_k.yaml │ │ │ │ ├── sar_conda.yaml │ │ │ │ ├── sar_score.yaml │ │ │ │ ├── sar_train.yaml │ │ │ │ └── stratified_splitter.yaml │ │ ├── azureml_utils.py │ │ ├── svd_training.py │ │ └── wide_deep_training.py │ ├── common │ │ ├── __init__.py │ │ ├── constants.py │ │ ├── general_utils.py │ │ ├── gpu_utils.py │ │ ├── notebook_memory_management.py │ │ ├── notebook_utils.py │ │ ├── plot.py │ │ ├── python_utils.py │ │ ├── spark_utils.py │ │ ├── tf_utils.py │ │ └── timer.py │ ├── dataset │ │ ├── __init__.py │ │ ├── amazon_reviews.py │ │ ├── blob_utils.py │ │ ├── cosmos_cli.py │ │ ├── covid_utils.py │ │ ├── criteo.py │ │ ├── download_utils.py │ │ ├── mind.py │ │ ├── movielens.py │ │ ├── pandas_df_utils.py │ │ ├── python_splitters.py │ │ ├── spark_splitters.py │ │ ├── sparse.py │ │ ├── split_utils.py │ │ └── wikidata.py │ ├── evaluation │ │ ├── __init__.py │ │ ├── python_evaluation.py │ │ └── spark_evaluation.py │ ├── recommender │ │ ├── __init__.py │ │ ├── cornac │ │ │ ├── __init__.py │ │ │ └── cornac_utils.py │ │ ├── deeprec │ │ │ ├── DataModel │ │ │ │ └── ImplicitCF.py │ │ │ ├── __init__.py │ │ │ ├── config │ │ │ │ ├── asvd.yaml │ │ │ │ ├── caser.yaml │ │ │ │ ├── gru4rec.yaml │ │ │ │ ├── lightgcn.yaml │ │ │ │ ├── nextitnet.yaml │ │ │ │ └── sli_rec.yaml │ │ │ ├── deeprec_utils.py │ │ │ ├── io │ │ │ │ ├── __init__.py │ │ │ │ ├── dkn_iterator.py │ │ │ │ ├── iterator.py │ │ │ │ ├── nextitnet_iterator.py │ │ │ │ └── sequential_iterator.py │ │ │ └── models │ │ │ │ ├── __init__.py │ │ │ │ ├── base_model.py │ │ │ │ ├── dkn.py │ │ │ │ ├── graphrec │ │ │ │ └── lightgcn.py │ │ │ │ ├── sequential │ │ │ │ ├── asvd.py │ │ │ │ ├── caser.py │ │ │ │ ├── gru4rec.py │ │ │ │ ├── nextitnet.py │ │ │ │ ├── rnn_cell_implement.py │ │ │ │ ├── sequential_base_model.py │ │ │ │ └── sli_rec.py │ │ │ │ └── xDeepFM.py │ │ ├── fastai │ │ │ ├── __init__.py │ │ │ └── fastai_utils.py │ │ ├── geoimc │ │ │ ├── __init__.py │ │ │ ├── geoimc_algorithm.py │ │ │ ├── geoimc_data.py │ │ │ ├── geoimc_predict.py │ │ │ └── geoimc_utils.py │ │ ├── lightfm │ │ │ ├── __init__.py │ │ │ └── lightfm_utils.py │ │ ├── lightgbm │ │ │ ├── __init__.py │ │ │ └── lightgbm_utils.py │ │ ├── ncf │ │ │ ├── __init__.py │ │ │ ├── dataset.py │ │ │ └── ncf_singlenode.py │ │ ├── newsrec │ │ │ ├── __init__.py │ │ │ ├── io │ │ │ │ ├── __init__.py │ │ │ │ ├── mind_all_iterator.py │ │ │ │ └── mind_iterator.py │ │ │ ├── models │ │ │ │ ├── __init__.py │ │ │ │ ├── base_model.py │ │ │ │ ├── layers.py │ │ │ │ ├── lstur.py │ │ │ │ ├── naml.py │ │ │ │ ├── npa.py │ │ │ │ └── nrms.py │ │ │ └── newsrec_utils.py │ │ ├── rbm │ │ │ ├── __init__.py │ │ │ └── rbm.py │ │ ├── rlrmc │ │ │ ├── RLRMCalgorithm.py │ │ │ ├── RLRMCdataset.py │ │ │ ├── __init__.py │ │ │ └── conjugate_gradient_ms.py │ │ ├── sar │ │ │ ├── __init__.py │ │ │ └── sar_singlenode.py │ │ ├── surprise │ │ │ ├── __init__.py │ │ │ └── surprise_utils.py │ │ ├── tfidf │ │ │ ├── __init__.py │ │ │ └── tfidf_utils.py │ │ ├── vowpal_wabbit │ │ │ ├── __init__.py │ │ │ └── vw.py │ │ └── wide_deep │ │ │ ├── __init__.py │ │ │ └── wide_deep_utils.py │ └── tuning │ │ ├── __init__.py │ │ ├── nni │ │ ├── ncf_training.py │ │ ├── ncf_utils.py │ │ ├── nni_utils.py │ │ └── svd_training.py │ │ └── parameter_sweep.py ├── sentencepiece │ ├── CONTRIBUTING.md │ ├── LICENSE │ ├── README.md │ ├── appveyor.yml │ ├── config.h.in │ ├── data │ │ ├── extract_headers.pl │ │ ├── gen_spec_parser.pl │ │ ├── gen_unicode_scripts_code.pl │ │ ├── ids_denorm.tsv │ │ ├── ids_norm.tsv │ │ ├── nfkc.tsv │ │ ├── nfkc_cf.tsv │ │ ├── nmt_nfkc.tsv │ │ └── nmt_nfkc_cf.tsv │ ├── doc │ │ ├── api.md │ │ ├── experiments.md │ │ ├── normalization.md │ │ ├── options.md │ │ └── special_symbols.md │ ├── python │ │ ├── MANIFEST.in │ │ ├── README.md │ │ ├── add_new_vocab.ipynb │ │ ├── build_bundled.sh │ │ ├── make_py_wheel.sh │ │ ├── make_py_wheel_mac.sh │ │ ├── once.h │ │ ├── sentencepiece_python_module_example.ipynb │ │ ├── setup.cfg │ │ ├── setup.py │ │ ├── src │ │ │ └── sentencepiece │ │ │ │ ├── __init__.py │ │ │ │ ├── sentencepiece.i │ │ │ │ ├── sentencepiece_model_pb2.py │ │ │ │ ├── sentencepiece_pb2.py │ │ │ │ └── sentencepiece_wrap.cxx │ │ └── test │ │ │ ├── __init__.py │ │ │ ├── sentencepiece_test.py │ │ │ ├── test_ja_model.model │ │ │ └── test_model.model │ ├── sentencepiece.pc.in │ ├── src │ │ ├── bpe_model.cc │ │ ├── bpe_model.h │ │ ├── bpe_model_test.cc │ │ ├── bpe_model_trainer.cc │ │ ├── bpe_model_trainer.h │ │ ├── bpe_model_trainer_test.cc │ │ ├── builder.cc │ │ ├── builder.h │ │ ├── builder_test.cc │ │ ├── builtin_pb │ │ │ ├── sentencepiece.pb.cc │ │ │ ├── sentencepiece.pb.h │ │ │ ├── sentencepiece_model.pb.cc │ │ │ └── sentencepiece_model.pb.h │ │ ├── char_model.cc │ │ ├── char_model.h │ │ ├── char_model_test.cc │ │ ├── char_model_trainer.cc │ │ ├── char_model_trainer.h │ │ ├── char_model_trainer_test.cc │ │ ├── common.h │ │ ├── compile_charsmap_main.cc │ │ ├── error.cc │ │ ├── filesystem.cc │ │ ├── filesystem.h │ │ ├── filesystem_test.cc │ │ ├── freelist.h │ │ ├── freelist_test.cc │ │ ├── init.h │ │ ├── init_test.cc │ │ ├── model_factory.cc │ │ ├── model_factory.h │ │ ├── model_factory_test.cc │ │ ├── model_interface.cc │ │ ├── model_interface.h │ │ ├── model_interface_test.cc │ │ ├── normalization_rule.h │ │ ├── normalizer.cc │ │ ├── normalizer.h │ │ ├── normalizer_test.cc │ │ ├── pretokenizer_for_training.cc │ │ ├── pretokenizer_for_training.h │ │ ├── pretokenizer_for_training_test.cc │ │ ├── sentencepiece.proto │ │ ├── sentencepiece_model.proto │ │ ├── sentencepiece_model_pb2.py │ │ ├── sentencepiece_processor.cc │ │ ├── sentencepiece_processor.h │ │ ├── sentencepiece_processor_test.cc │ │ ├── sentencepiece_trainer.cc │ │ ├── sentencepiece_trainer.h │ │ ├── sentencepiece_trainer_test.cc │ │ ├── spec_parser.h │ │ ├── spm_decode_main.cc │ │ ├── spm_encode_main.cc │ │ ├── spm_export_vocab_main.cc │ │ ├── spm_normalize_main.cc │ │ ├── spm_train_main.cc │ │ ├── test_main.cc │ │ ├── testharness.cc │ │ ├── testharness.h │ │ ├── trainer_factory.cc │ │ ├── trainer_factory.h │ │ ├── trainer_factory_test.cc │ │ ├── trainer_interface.cc │ │ ├── trainer_interface.h │ │ ├── trainer_interface_test.cc │ │ ├── unicode_script.cc │ │ ├── unicode_script.h │ │ ├── unicode_script_map.h │ │ ├── unicode_script_test.cc │ │ ├── unigram_model.cc │ │ ├── unigram_model.h │ │ ├── unigram_model_test.cc │ │ ├── unigram_model_trainer.cc │ │ ├── unigram_model_trainer.h │ │ ├── unigram_model_trainer_test.cc │ │ ├── util.cc │ │ ├── util.h │ │ ├── util_test.cc │ │ ├── word_model.cc │ │ ├── word_model.h │ │ ├── word_model_test.cc │ │ ├── word_model_trainer.cc │ │ ├── word_model_trainer.h │ │ └── word_model_trainer_test.cc │ ├── tensorflow │ │ └── README.md │ ├── test.bat │ ├── test.sh │ └── third_party │ │ ├── absl │ │ ├── LICENSE │ │ ├── container │ │ │ ├── flat_hash_map.h │ │ │ └── flat_hash_set.h │ │ ├── flags │ │ │ ├── flag.cc │ │ │ ├── flag.h │ │ │ └── parse.h │ │ ├── memory │ │ │ └── memory.h │ │ └── strings │ │ │ ├── ascii.h │ │ │ ├── match.h │ │ │ ├── numbers.h │ │ │ ├── str_cat.h │ │ │ ├── str_format.h │ │ │ ├── str_join.h │ │ │ ├── str_replace.h │ │ │ ├── str_split.h │ │ │ ├── string_view.cc │ │ │ ├── string_view.h │ │ │ └── strip.h │ │ ├── darts_clone │ │ ├── LICENSE │ │ └── darts.h │ │ ├── esaxx │ │ ├── LICENSE │ │ ├── esa.hxx │ │ └── sais.hxx │ │ └── protobuf-lite │ │ ├── LICENSE │ │ ├── arena.cc │ │ ├── arenastring.cc │ │ ├── bytestream.cc │ │ ├── coded_stream.cc │ │ ├── common.cc │ │ ├── extension_set.cc │ │ ├── generated_enum_util.cc │ │ ├── generated_message_table_driven_lite.cc │ │ ├── generated_message_util.cc │ │ ├── google │ │ └── protobuf │ │ │ ├── any.h │ │ │ ├── arena.h │ │ │ ├── arena_impl.h │ │ │ ├── arenastring.h │ │ │ ├── descriptor.h │ │ │ ├── extension_set.h │ │ │ ├── extension_set_inl.h │ │ │ ├── generated_enum_reflection.h │ │ │ ├── generated_enum_util.h │ │ │ ├── generated_message_table_driven.h │ │ │ ├── generated_message_table_driven_lite.h │ │ │ ├── generated_message_util.h │ │ │ ├── has_bits.h │ │ │ ├── implicit_weak_message.h │ │ │ ├── io │ │ │ ├── coded_stream.h │ │ │ ├── io_win32.h │ │ │ ├── zero_copy_stream.h │ │ │ ├── zero_copy_stream_impl.h │ │ │ └── zero_copy_stream_impl_lite.h │ │ │ ├── map.h │ │ │ ├── map_entry_lite.h │ │ │ ├── map_field_lite.h │ │ │ ├── map_type_handler.h │ │ │ ├── message_lite.h │ │ │ ├── metadata_lite.h │ │ │ ├── parse_context.h │ │ │ ├── port.h │ │ │ ├── port_def.inc │ │ │ ├── port_undef.inc │ │ │ ├── repeated_field.h │ │ │ ├── stubs │ │ │ ├── bytestream.h │ │ │ ├── callback.h │ │ │ ├── casts.h │ │ │ ├── common.h │ │ │ ├── hash.h │ │ │ ├── int128.h │ │ │ ├── logging.h │ │ │ ├── macros.h │ │ │ ├── map_util.h │ │ │ ├── mutex.h │ │ │ ├── once.h │ │ │ ├── platform_macros.h │ │ │ ├── port.h │ │ │ ├── status.h │ │ │ ├── statusor.h │ │ │ ├── stl_util.h │ │ │ ├── stringpiece.h │ │ │ ├── stringprintf.h │ │ │ ├── strutil.h │ │ │ └── time.h │ │ │ ├── unknown_field_set.h │ │ │ └── wire_format_lite.h │ │ ├── implicit_weak_message.cc │ │ ├── int128.cc │ │ ├── io_win32.cc │ │ ├── message_lite.cc │ │ ├── parse_context.cc │ │ ├── repeated_field.cc │ │ ├── status.cc │ │ ├── statusor.cc │ │ ├── stringpiece.cc │ │ ├── stringprintf.cc │ │ ├── structurally_valid.cc │ │ ├── strutil.cc │ │ ├── time.cc │ │ ├── wire_format_lite.cc │ │ ├── zero_copy_stream.cc │ │ ├── zero_copy_stream_impl.cc │ │ └── zero_copy_stream_impl_lite.cc ├── tensorflow_examples │ ├── __init__.py │ ├── lite │ │ ├── __init__.py │ │ └── model_maker │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── cli │ │ │ ├── cli.py │ │ │ └── cli_test.py │ │ │ ├── core │ │ │ ├── __init__.py │ │ │ ├── compat.py │ │ │ ├── data_util │ │ │ │ ├── __init__.py │ │ │ │ ├── data_util.py │ │ │ │ ├── dataloader.py │ │ │ │ ├── dataloader_test.py │ │ │ │ ├── image_dataloader.py │ │ │ │ ├── image_dataloader_test.py │ │ │ │ ├── testdata │ │ │ │ │ └── squad_testdata │ │ │ │ │ │ ├── dev-v1.1.json │ │ │ │ │ │ ├── dev-v2.0.json │ │ │ │ │ │ ├── train-v1.1.json │ │ │ │ │ │ └── train-v2.0.json │ │ │ │ ├── text_dataloader.py │ │ │ │ └── text_dataloader_test.py │ │ │ ├── export_format.py │ │ │ ├── file_util.py │ │ │ ├── optimization │ │ │ │ ├── __init__.py │ │ │ │ └── warmup.py │ │ │ ├── task │ │ │ │ ├── __init__.py │ │ │ │ ├── classification_model.py │ │ │ │ ├── classification_model_test.py │ │ │ │ ├── configs.py │ │ │ │ ├── custom_model.py │ │ │ │ ├── custom_model_test.py │ │ │ │ ├── hub_loader.py │ │ │ │ ├── hub_loader_test.py │ │ │ │ ├── image_classifier.py │ │ │ │ ├── image_classifier_test.py │ │ │ │ ├── image_classifier_v1_test.py │ │ │ │ ├── image_preprocessing.py │ │ │ │ ├── image_preprocessing_test.py │ │ │ │ ├── metadata_writer_for_image_classifier.py │ │ │ │ ├── metadata_writers │ │ │ │ │ ├── bert │ │ │ │ │ │ ├── metadata_writer_for_bert.py │ │ │ │ │ │ ├── question_answerer │ │ │ │ │ │ │ └── metadata_writer_for_bert_question_answerer.py │ │ │ │ │ │ └── text_classifier │ │ │ │ │ │ │ └── metadata_writer_for_bert_text_classifier.py │ │ │ │ │ ├── metadata_writer.py │ │ │ │ │ └── text_classifier │ │ │ │ │ │ └── metadata_writer_for_text_classifier.py │ │ │ │ ├── model_spec.py │ │ │ │ ├── model_spec_test.py │ │ │ │ ├── model_util.py │ │ │ │ ├── model_util_test.py │ │ │ │ ├── model_util_v1_test.py │ │ │ │ ├── question_answer.py │ │ │ │ ├── question_answer_test.py │ │ │ │ ├── question_answer_v1_test.py │ │ │ │ ├── testdata │ │ │ │ │ ├── average_word_vec_metadata.json │ │ │ │ │ ├── bert_classifier_metadata.json │ │ │ │ │ ├── bert_qa_metadata.json │ │ │ │ │ ├── efficientnet_lite0_metadata.json │ │ │ │ │ ├── hub_module_v1_mini │ │ │ │ │ │ ├── saved_model.pb │ │ │ │ │ │ └── tfhub_module.pb │ │ │ │ │ ├── hub_module_v1_mini_train │ │ │ │ │ │ ├── saved_model.pb │ │ │ │ │ │ ├── tfhub_module.pb │ │ │ │ │ │ └── variables │ │ │ │ │ │ │ ├── variables.data-00000-of-00001 │ │ │ │ │ │ │ └── variables.index │ │ │ │ │ └── saved_model_v2_mini │ │ │ │ │ │ ├── saved_model.pb │ │ │ │ │ │ └── variables │ │ │ │ │ │ ├── variables.data-00000-of-00001 │ │ │ │ │ │ └── variables.index │ │ │ │ ├── text_classifier.py │ │ │ │ ├── text_classifier_test.py │ │ │ │ ├── text_classifier_v1_test.py │ │ │ │ └── train_image_classifier_lib.py │ │ │ └── test_util.py │ │ │ ├── demo │ │ │ ├── __init__.py │ │ │ ├── image_classification.ipynb │ │ │ ├── image_classification_demo.py │ │ │ ├── image_classification_demo_test.py │ │ │ ├── question_answer_demo.py │ │ │ ├── text_classification.ipynb │ │ │ ├── text_classification_demo.py │ │ │ └── text_classification_demo_test.py │ │ │ └── pip_package │ │ │ ├── create_venv.sh │ │ │ ├── setup.py │ │ │ └── test_pip_package.sh │ ├── models │ │ ├── __init__.py │ │ ├── dcgan │ │ │ ├── __init__.py │ │ │ ├── dcgan.py │ │ │ └── dcgan_test.py │ │ ├── densenet │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── densenet.py │ │ │ ├── densenet_distributed_test.py │ │ │ ├── densenet_test.py │ │ │ ├── distributed_train.py │ │ │ ├── train.py │ │ │ └── utils.py │ │ ├── nmt_with_attention │ │ │ ├── __init__.py │ │ │ ├── distributed_test.py │ │ │ ├── distributed_train.py │ │ │ ├── nmt.py │ │ │ ├── nmt_test.py │ │ │ ├── train.py │ │ │ └── utils.py │ │ └── pix2pix │ │ │ ├── __init__.py │ │ │ ├── data_download.py │ │ │ ├── pix2pix.py │ │ │ └── pix2pix_test.py │ └── profiling │ │ ├── imagenet_preprocessing_ineffecient_input_pipeline.py │ │ └── resnet_model.py ├── tensorflow_recommenders │ ├── BUILD │ ├── __init__.py │ ├── examples │ │ ├── BUILD │ │ ├── __init__.py │ │ ├── movielens.py │ │ └── nbtool.py │ ├── experimental │ │ ├── BUILD │ │ ├── __init__.py │ │ ├── layers │ │ │ ├── BUILD │ │ │ ├── __init__.py │ │ │ └── embedding │ │ │ │ ├── BUILD │ │ │ │ ├── __init__.py │ │ │ │ ├── partial_tpu_embedding.py │ │ │ │ └── partial_tpu_embedding_test.py │ │ ├── models │ │ │ ├── BUILD │ │ │ ├── __init__.py │ │ │ ├── ranking.py │ │ │ └── ranking_test.py │ │ └── optimizers │ │ │ ├── BUILD │ │ │ ├── __init__.py │ │ │ ├── composite_optimizer.py │ │ │ └── composite_optimizer_test.py │ ├── layers │ │ ├── BUILD │ │ ├── __init__.py │ │ ├── blocks.py │ │ ├── embedding │ │ │ ├── __init__.py │ │ │ ├── tpu_embedding_layer.py │ │ │ └── tpu_embedding_layer_test.py │ │ ├── factorized_top_k.py │ │ ├── factorized_top_k_test.py │ │ ├── feature_interaction │ │ │ ├── BUILD │ │ │ ├── __init__.py │ │ │ ├── dcn.py │ │ │ ├── dcn_test.py │ │ │ ├── dot_interaction.py │ │ │ └── dot_interaction_test.py │ │ ├── loss.py │ │ └── loss_test.py │ ├── metrics │ │ ├── BUILD │ │ ├── __init__.py │ │ ├── factorized_top_k.py │ │ └── factorized_top_k_test.py │ ├── models │ │ ├── BUILD │ │ ├── __init__.py │ │ ├── base.py │ │ └── base_test.py │ ├── tasks │ │ ├── BUILD │ │ ├── __init__.py │ │ ├── base.py │ │ ├── ranking.py │ │ ├── ranking_test.py │ │ ├── retrieval.py │ │ └── retrieval_test.py │ └── types.py ├── wandb │ └── redirect.py └── weighted_boxes_fusion │ ├── CHANGES.md │ ├── LICENSE │ ├── README.md │ ├── benchmark_coco │ ├── README.md │ └── run_benchmark_coco.py │ ├── benchmark_nlp │ ├── README.md │ └── run_benchmark_nlp.py │ ├── benchmark_oid │ ├── README.md │ └── run_benchmark_oid.py │ ├── ensemble_boxes │ ├── __init__.py │ ├── ensemble_boxes_nms.py │ ├── ensemble_boxes_nmw.py │ ├── ensemble_boxes_wbf.py │ ├── ensemble_boxes_wbf_1d.py │ ├── ensemble_boxes_wbf_3d.py │ └── ensemble_boxes_wbf_experimental.py │ ├── examples │ ├── example.py │ ├── example_1d.py │ └── example_3d.py │ ├── setup.py │ └── tests │ └── test_bbox.py └── utils ├── README.md ├── gezi ├── __init__.py ├── avg_score.py ├── bigdata_util.py ├── bleu.py ├── common.py ├── geneticalgorithm.py ├── gezi_util.py ├── hash.py ├── libgezi_util.py ├── melt │ ├── __init__.py │ ├── tfrecords.py │ └── util.py ├── metrics │ ├── README.md │ ├── __init__.py │ ├── bleu │ │ ├── LICENSE │ │ ├── __init__.py │ │ ├── bleu.py │ │ └── bleu_scorer.py │ ├── cider │ │ ├── __init__.py │ │ ├── cider.py │ │ └── cider_scorer.py │ ├── ciderD │ │ ├── __init__.py │ │ ├── ciderD.py │ │ └── ciderD_scorer.py │ ├── correlation │ │ ├── __init__.py │ │ └── correlation.py │ ├── eval.py │ ├── image │ │ ├── __init__.py │ │ └── semantic_seg.py │ ├── meteor │ │ ├── __init__.py │ │ ├── data │ │ │ └── paraphrase-en.gz │ │ ├── meteor-1.5.jar │ │ └── meteor.py │ ├── metrics.py │ ├── ner.py │ ├── new_cider │ │ ├── __init__.py │ │ ├── cider.py │ │ └── cider_scorer.py │ ├── rouge │ │ ├── __init__.py │ │ └── rouge.py │ ├── stats │ │ ├── __init__.py │ │ ├── _stats.c │ │ ├── _stats.pyx │ │ ├── build.sh │ │ └── setup.py │ └── tokenizer │ │ ├── __init__.py │ │ ├── ptbtokenizer.py │ │ └── stanford-corenlp-3.4.1.jar ├── ngram.py ├── nowarning.py ├── plot.py ├── pydict.py ├── rank_metrics.py ├── segment.py ├── setup.py ├── summary.py ├── test │ ├── test_get_single_cn.py │ └── test_ngrams.py ├── timer.py ├── topn.py ├── util.py ├── utils │ ├── __init__.py │ └── logging.py ├── vocabulary.py ├── word_counter.py └── zhtools │ ├── Mandarin.dat │ ├── __init__.py │ ├── chconv.py │ ├── langconv.py │ ├── test_langconv.py │ ├── xpinyin.py │ └── zh_wiki.py ├── husky ├── __init__.py ├── callbacks │ ├── __init__.py │ ├── callbacks.py │ ├── evaluate.py │ ├── swa.py │ └── tqdm_progress_bar.py ├── ema.py ├── optimization.py └── train.py ├── lele ├── README.md ├── __init__.py ├── apps │ ├── __init__.py │ └── train.py ├── distributed │ ├── __init__.py │ └── parallel.py ├── fastai │ ├── __init__.py │ ├── core.py │ ├── imports │ │ ├── __init__.py │ │ ├── core.py │ │ └── torch.py │ ├── layers.py │ ├── text │ │ ├── __init__.py │ │ ├── models.py │ │ └── qrnn │ │ │ ├── __init__.py │ │ │ ├── forget_mult.py │ │ │ └── qrnn.py │ └── torch_core.py ├── layers │ ├── README.md │ ├── __init__.py │ ├── activation.py │ ├── classify_layer.py │ ├── elmo.py │ ├── elmo │ │ ├── __init__.py │ │ ├── classify_layer.py │ │ ├── elmo.py │ │ ├── embedding_layer.py │ │ ├── encoder_base.py │ │ ├── highway.py │ │ ├── lstm.py │ │ ├── lstm_cell_with_projection.py │ │ ├── token_embedder.py │ │ └── util.py │ ├── embedding_layer.py │ ├── encoder_base.py │ ├── hash_embedding.py │ ├── highway.py │ ├── large_embedding.py │ ├── layers.py │ ├── lstm.py │ ├── lstm_cell_with_projection.py │ ├── token_embedder.py │ ├── transformer │ │ ├── __init__.py │ │ └── transformer.py │ └── util.py ├── losses │ ├── __init__.py │ ├── losses.py │ └── lovasz.py ├── nlp │ └── pretrain │ │ ├── README.md │ │ ├── mlm.py │ │ └── rtd.py ├── ops │ ├── __init__.py │ └── ops.py ├── training │ ├── __init__.py │ └── optimizers.py └── util.py └── melt ├── __init__.py ├── apps ├── __init__.py ├── config.py ├── image_processing.py ├── init.py └── train.py ├── cnn ├── __init__.py ├── cnn.py ├── conv2d.py └── qanet.py ├── deepctr ├── __init__.py └── layers.py ├── distributed ├── __init__.py └── util.py ├── eager ├── __init__.py ├── train.py └── util.py ├── encoder ├── __init__.py ├── embedding_layer.py └── transformer.py ├── flow ├── __init__.py ├── flow.py ├── test.py ├── test_once.py ├── train.py └── train_once.py ├── global_objectives ├── README.md ├── __init__.py ├── loss_layers.py ├── loss_layers_example.py ├── loss_layers_test.py ├── test_all.py ├── util.py └── util_test.py ├── image ├── __init__.py ├── augment.py ├── image_decoder.py ├── image_embedding.py ├── image_model.py └── image_processing.py ├── inference ├── __init__.py ├── predictor.py └── predictor_base.py ├── layers ├── __init__.py ├── cnn │ ├── __init__.py │ ├── cnn.py │ ├── convnet.py │ └── qanet.py ├── layers.py ├── optimizers.py ├── rnn │ ├── __init__.py │ └── rnn.py └── transformer │ ├── __init__.py │ └── transformer.py ├── losses ├── __init__.py └── losses.py ├── metrics ├── __init__.py ├── metrics.py └── rank_metrics.py ├── models ├── __init__.py ├── bert.py └── mlp.py ├── ops ├── __init__.py ├── nn_impl.py ├── ops.py └── sparse_ops.py ├── pretrain ├── __init__.py └── bert.py ├── rnn ├── __init__.py └── rnn.py ├── seq2seq ├── README.md ├── __init__.py ├── attention_decoder_fn.py ├── attention_wrapper.py ├── basic_decoder.py ├── beam_decoder.py ├── beam_decoder_fn.py ├── beam_search.py ├── beam_search_decoder.py ├── decoder.py ├── decoder_fn.py ├── exp │ └── beam_decoder.py ├── helper.py ├── legacy │ ├── beam_decoder.py │ └── beam_search_decoder.py ├── logprobs_decoder.py ├── loss.py ├── official │ └── beam_search_decoder.py └── seq2seq.py ├── setup.py ├── slim2 ├── __init__.py ├── base_nets_factory.py ├── layers.py └── preprocessing_factory.py ├── tfrecords ├── __init__.py ├── dataset.py ├── dataset_decode.py ├── decode_then_shuffle.py ├── libsvm_decode.py ├── read.py ├── shuffle_then_decode.py └── write.py ├── tools ├── checkpoint2pb.py ├── checkpoint2savedmodel.py ├── count-records.py ├── delete-old-models.py ├── prepare-finetune-withhistory.py ├── prepare-finetune.py ├── rename-variables.py ├── reset-model-top-scope.py ├── show-records.py └── show-var-of-model.py ├── torch ├── __init__.py └── train.py ├── training ├── __init__.py ├── adamax.py ├── bert │ ├── __init__.py │ └── optimization.py ├── learning_rate_decay.py └── training.py ├── util.py ├── utils ├── __init__.py ├── embsim.py ├── summary.py └── weight_decay.py └── variable ├── __init__.py └── variable.py /.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/.gitignore -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/README.md -------------------------------------------------------------------------------- /projects/kaggle/usp/dataset-metadata.json: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/dataset-metadata.json -------------------------------------------------------------------------------- /projects/kaggle/usp/input: -------------------------------------------------------------------------------- 1 | /home/huigecheng/data/kaggle -------------------------------------------------------------------------------- /projects/kaggle/usp/jupyter/ana.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/jupyter/ana.ipynb -------------------------------------------------------------------------------- /projects/kaggle/usp/jupyter/debug.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/jupyter/debug.ipynb -------------------------------------------------------------------------------- /projects/kaggle/usp/jupyter/ensemble.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/jupyter/ensemble.ipynb -------------------------------------------------------------------------------- /projects/kaggle/usp/jupyter/prepare.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/jupyter/prepare.ipynb -------------------------------------------------------------------------------- /projects/kaggle/usp/jupyter/stacking.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/jupyter/stacking.ipynb -------------------------------------------------------------------------------- /projects/kaggle/usp/jupyter/stacking2.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/jupyter/stacking2.ipynb -------------------------------------------------------------------------------- /projects/kaggle/usp/prepare/gen-records.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/prepare/gen-records.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/config.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/config.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/dataset-metadata.json: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/dataset-metadata.json -------------------------------------------------------------------------------- /projects/kaggle/usp/src/dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/dataset.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/ensemble: -------------------------------------------------------------------------------- 1 | ensemble.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/ensemble.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/ensemble.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/ensemble_conf.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/ensemble_conf.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/eval.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/eval.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/flags/base: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/flags/base -------------------------------------------------------------------------------- /projects/kaggle/usp/src/flags/best: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/flags/best -------------------------------------------------------------------------------- /projects/kaggle/usp/src/flags/best2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/flags/best2 -------------------------------------------------------------------------------- /projects/kaggle/usp/src/infer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/infer.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/main.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/mlm-main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/mlm-main.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/postprocess.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/postprocess.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/preprocess.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/preprocess.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/stacking.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/stacking.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/tf/loss.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/tf/loss.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/tf/model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/tf/model.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/torch/dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/torch/dataset.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/torch/loss.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/torch/loss.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/torch/model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/torch/model.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/projects/kaggle/usp/src/util.py -------------------------------------------------------------------------------- /projects/kaggle/usp/src/wandb/debug-cli.log: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /projects/kaggle/usp/working: -------------------------------------------------------------------------------- 1 | /home/huigecheng/working/usp/ -------------------------------------------------------------------------------- /third/GraphEmbedding/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/LICENSE -------------------------------------------------------------------------------- /third/GraphEmbedding/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/README.md -------------------------------------------------------------------------------- /third/GraphEmbedding/examples/alias.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/examples/alias.py -------------------------------------------------------------------------------- /third/GraphEmbedding/examples/deepwalk_wiki.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/examples/deepwalk_wiki.py -------------------------------------------------------------------------------- /third/GraphEmbedding/examples/line_wiki.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/examples/line_wiki.py -------------------------------------------------------------------------------- /third/GraphEmbedding/examples/node2vec_wiki.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/examples/node2vec_wiki.py -------------------------------------------------------------------------------- /third/GraphEmbedding/examples/sdne_wiki.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/examples/sdne_wiki.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ez_setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ez_setup.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/__init__.py: -------------------------------------------------------------------------------- 1 | from .models import * -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/alias.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/alias.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/classify.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/classify.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/models/__init__.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/models/deepwalk.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/models/deepwalk.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/models/line.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/models/line.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/models/node2vec.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/models/node2vec.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/models/sdne.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/models/sdne.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/models/struc2vec.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/models/struc2vec.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/utils.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge/walker.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge/walker.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/__init__.py: -------------------------------------------------------------------------------- 1 | from .models import * -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/alias.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/alias.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/classify.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/classify.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/models/__init__.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/models/deepwalk.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/models/deepwalk.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/models/line.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/models/line.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/models/node2vec.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/models/node2vec.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/models/sdne.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/models/sdne.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/models/struc2vec.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/models/struc2vec.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/utils.py -------------------------------------------------------------------------------- /third/GraphEmbedding/ge2/walker.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/ge2/walker.py -------------------------------------------------------------------------------- /third/GraphEmbedding/pics/code.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/pics/code.png -------------------------------------------------------------------------------- /third/GraphEmbedding/pics/deepctrbot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/pics/deepctrbot.png -------------------------------------------------------------------------------- /third/GraphEmbedding/pics/edge_list.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/pics/edge_list.png -------------------------------------------------------------------------------- /third/GraphEmbedding/pics/weichennote.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/pics/weichennote.png -------------------------------------------------------------------------------- /third/GraphEmbedding/setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/GraphEmbedding/setup.py -------------------------------------------------------------------------------- /third/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/README.md -------------------------------------------------------------------------------- /third/__init__.py: -------------------------------------------------------------------------------- 1 | import third.bert 2 | -------------------------------------------------------------------------------- /third/bert/CONTRIBUTING.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/CONTRIBUTING.md -------------------------------------------------------------------------------- /third/bert/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/LICENSE -------------------------------------------------------------------------------- /third/bert/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/README.md -------------------------------------------------------------------------------- /third/bert/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/__init__.py -------------------------------------------------------------------------------- /third/bert/create_pretraining_data.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/create_pretraining_data.py -------------------------------------------------------------------------------- /third/bert/extract_features.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/extract_features.py -------------------------------------------------------------------------------- /third/bert/modeling.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/modeling.py -------------------------------------------------------------------------------- /third/bert/modeling_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/modeling_test.py -------------------------------------------------------------------------------- /third/bert/multilingual.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/multilingual.md -------------------------------------------------------------------------------- /third/bert/optimization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/optimization.py -------------------------------------------------------------------------------- /third/bert/optimization_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/optimization_test.py -------------------------------------------------------------------------------- /third/bert/run-char.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/run-char.sh -------------------------------------------------------------------------------- /third/bert/run_classifier.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/run_classifier.py -------------------------------------------------------------------------------- /third/bert/run_pretraining.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/run_pretraining.py -------------------------------------------------------------------------------- /third/bert/run_squad.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/run_squad.py -------------------------------------------------------------------------------- /third/bert/tokenization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/tokenization.py -------------------------------------------------------------------------------- /third/bert/tokenization_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/bert/tokenization_test.py -------------------------------------------------------------------------------- /third/cocolm/configuration_cocolm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/cocolm/configuration_cocolm.py -------------------------------------------------------------------------------- /third/cocolm/convert_state_dict.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/cocolm/convert_state_dict.py -------------------------------------------------------------------------------- /third/cocolm/modeling_cocolm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/cocolm/modeling_cocolm.py -------------------------------------------------------------------------------- /third/cocolm/tokenization_cocolm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/cocolm/tokenization_cocolm.py -------------------------------------------------------------------------------- /third/cocolm/tokenization_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/cocolm/tokenization_utils.py -------------------------------------------------------------------------------- /third/efficientnet/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/__init__.py -------------------------------------------------------------------------------- /third/efficientnet/__version__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/__version__.py -------------------------------------------------------------------------------- /third/efficientnet/keras.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/keras.py -------------------------------------------------------------------------------- /third/efficientnet/model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/model.py -------------------------------------------------------------------------------- /third/efficientnet/preprocessing.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/preprocessing.py -------------------------------------------------------------------------------- /third/efficientnet/tfkeras.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/tfkeras.py -------------------------------------------------------------------------------- /third/efficientnet/weights.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/efficientnet/weights.py -------------------------------------------------------------------------------- /third/fast_soft_sort/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/fast_soft_sort/jax_ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/fast_soft_sort/jax_ops.py -------------------------------------------------------------------------------- /third/fast_soft_sort/numpy_ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/fast_soft_sort/numpy_ops.py -------------------------------------------------------------------------------- /third/fast_soft_sort/pytorch_ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/fast_soft_sort/pytorch_ops.py -------------------------------------------------------------------------------- /third/fast_soft_sort/tf_ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/fast_soft_sort/tf_ops.py -------------------------------------------------------------------------------- /third/fast_soft_sort/third_party/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/fast_soft_sort/third_party/LICENSE -------------------------------------------------------------------------------- /third/fast_soft_sort/third_party/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/fast_soft_sort/third_party/isotonic.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/fast_soft_sort/third_party/isotonic.py -------------------------------------------------------------------------------- /third/focal_loss/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/focal_loss/__init__.py -------------------------------------------------------------------------------- /third/focal_loss/_binary_focal_loss.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/focal_loss/_binary_focal_loss.py -------------------------------------------------------------------------------- /third/focal_loss/_categorical_focal_loss.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/focal_loss/_categorical_focal_loss.py -------------------------------------------------------------------------------- /third/focal_loss/tests/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/focal_loss/tests/utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/focal_loss/tests/utils.py -------------------------------------------------------------------------------- /third/focal_loss/utils/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/focal_loss/utils/tests/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/focal_loss/utils/tests/test_validation.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/focal_loss/utils/tests/test_validation.py -------------------------------------------------------------------------------- /third/focal_loss/utils/validation.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/focal_loss/utils/validation.py -------------------------------------------------------------------------------- /third/global_objectives/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/README.md -------------------------------------------------------------------------------- /third/global_objectives/__init__.py: -------------------------------------------------------------------------------- 1 | from global_objectives.loss_layers import * 2 | -------------------------------------------------------------------------------- /third/global_objectives/loss_layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/loss_layers.py -------------------------------------------------------------------------------- /third/global_objectives/loss_layers_example.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/loss_layers_example.py -------------------------------------------------------------------------------- /third/global_objectives/loss_layers_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/loss_layers_test.py -------------------------------------------------------------------------------- /third/global_objectives/test_all.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/test_all.py -------------------------------------------------------------------------------- /third/global_objectives/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/util.py -------------------------------------------------------------------------------- /third/global_objectives/util_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/global_objectives/util_test.py -------------------------------------------------------------------------------- /third/glove/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/LICENSE -------------------------------------------------------------------------------- /third/glove/Makefile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/Makefile -------------------------------------------------------------------------------- /third/glove/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/README.md -------------------------------------------------------------------------------- /third/glove/demo.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/demo.sh -------------------------------------------------------------------------------- /third/glove/eval/matlab/WordLookup.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/matlab/WordLookup.m -------------------------------------------------------------------------------- /third/glove/eval/matlab/evaluate_vectors.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/matlab/evaluate_vectors.m -------------------------------------------------------------------------------- /third/glove/eval/matlab/read_and_evaluate.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/matlab/read_and_evaluate.m -------------------------------------------------------------------------------- /third/glove/eval/octave/WordLookup_octave.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/octave/WordLookup_octave.m -------------------------------------------------------------------------------- /third/glove/eval/python/distance.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/python/distance.py -------------------------------------------------------------------------------- /third/glove/eval/python/evaluate.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/python/evaluate.py -------------------------------------------------------------------------------- /third/glove/eval/python/word_analogy.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/eval/python/word_analogy.py -------------------------------------------------------------------------------- /third/glove/randomization.test.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/randomization.test.sh -------------------------------------------------------------------------------- /third/glove/src/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/README.md -------------------------------------------------------------------------------- /third/glove/src/common.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/common.c -------------------------------------------------------------------------------- /third/glove/src/common.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/common.h -------------------------------------------------------------------------------- /third/glove/src/cooccur.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/cooccur.c -------------------------------------------------------------------------------- /third/glove/src/glove.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/glove.c -------------------------------------------------------------------------------- /third/glove/src/shuffle.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/shuffle.c -------------------------------------------------------------------------------- /third/glove/src/vocab_count.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/glove/src/vocab_count.c -------------------------------------------------------------------------------- /third/image_segmentation_losses/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/image_segmentation_losses/README.md -------------------------------------------------------------------------------- /third/keras_applications/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/__init__.py -------------------------------------------------------------------------------- /third/keras_applications/densenet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/densenet.py -------------------------------------------------------------------------------- /third/keras_applications/imagenet_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/imagenet_utils.py -------------------------------------------------------------------------------- /third/keras_applications/inception_resnet_v2.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/inception_resnet_v2.py -------------------------------------------------------------------------------- /third/keras_applications/inception_v3.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/inception_v3.py -------------------------------------------------------------------------------- /third/keras_applications/mobilenet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/mobilenet.py -------------------------------------------------------------------------------- /third/keras_applications/mobilenet_v2.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/mobilenet_v2.py -------------------------------------------------------------------------------- /third/keras_applications/nasnet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/nasnet.py -------------------------------------------------------------------------------- /third/keras_applications/resnet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/resnet.py -------------------------------------------------------------------------------- /third/keras_applications/resnet50.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/resnet50.py -------------------------------------------------------------------------------- /third/keras_applications/resnet_common.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/resnet_common.py -------------------------------------------------------------------------------- /third/keras_applications/resnet_v2.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/resnet_v2.py -------------------------------------------------------------------------------- /third/keras_applications/resnext.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/resnext.py -------------------------------------------------------------------------------- /third/keras_applications/vgg16.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/vgg16.py -------------------------------------------------------------------------------- /third/keras_applications/vgg19.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/vgg19.py -------------------------------------------------------------------------------- /third/keras_applications/xception.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/keras_applications/xception.py -------------------------------------------------------------------------------- /third/official/Dockerfile.cpu: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/Dockerfile.cpu -------------------------------------------------------------------------------- /third/official/Dockerfile.gpu: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/Dockerfile.gpu -------------------------------------------------------------------------------- /third/official/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/LICENSE -------------------------------------------------------------------------------- /third/official/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/README.md -------------------------------------------------------------------------------- /third/official/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/benchmark/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/benchmark/benchmark_uploader.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/benchmark/benchmark_uploader.py -------------------------------------------------------------------------------- /third/official/benchmark/bert_benchmark.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/benchmark/bert_benchmark.py -------------------------------------------------------------------------------- /third/official/benchmark/keras_benchmark.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/benchmark/keras_benchmark.py -------------------------------------------------------------------------------- /third/official/benchmark/models/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/benchmark/squad_evaluate_v1_1.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/benchmark/squad_evaluate_v1_1.py -------------------------------------------------------------------------------- /third/official/mnist/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/README.md -------------------------------------------------------------------------------- /third/official/mnist/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/mnist/dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/dataset.py -------------------------------------------------------------------------------- /third/official/mnist/example3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/example3.png -------------------------------------------------------------------------------- /third/official/mnist/example5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/example5.png -------------------------------------------------------------------------------- /third/official/mnist/mnist.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/mnist.py -------------------------------------------------------------------------------- /third/official/mnist/mnist_eager.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/mnist_eager.py -------------------------------------------------------------------------------- /third/official/mnist/mnist_eager_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/mnist_eager_test.py -------------------------------------------------------------------------------- /third/official/mnist/mnist_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/mnist_test.py -------------------------------------------------------------------------------- /third/official/mnist/mnist_tpu.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/mnist/mnist_tpu.py -------------------------------------------------------------------------------- /third/official/modeling/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/modeling/hyperparams/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/modeling/model_training_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/modeling/model_training_utils.py -------------------------------------------------------------------------------- /third/official/modeling/tf_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/modeling/tf_utils.py -------------------------------------------------------------------------------- /third/official/nlp/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/README.md -------------------------------------------------------------------------------- /third/official/nlp/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/nlp/bert/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/README.md -------------------------------------------------------------------------------- /third/official/nlp/bert/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/official/nlp/bert/classifier_data_lib.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/classifier_data_lib.py -------------------------------------------------------------------------------- /third/official/nlp/bert/common_flags.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/common_flags.py -------------------------------------------------------------------------------- /third/official/nlp/bert/input_pipeline.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/input_pipeline.py -------------------------------------------------------------------------------- /third/official/nlp/bert/model_saving_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/model_saving_utils.py -------------------------------------------------------------------------------- /third/official/nlp/bert/run_classifier.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/run_classifier.py -------------------------------------------------------------------------------- /third/official/nlp/bert/run_pretraining.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/run_pretraining.py -------------------------------------------------------------------------------- /third/official/nlp/bert/run_squad.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/run_squad.py -------------------------------------------------------------------------------- /third/official/nlp/bert/squad_lib.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/squad_lib.py -------------------------------------------------------------------------------- /third/official/nlp/bert/tokenization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/tokenization.py -------------------------------------------------------------------------------- /third/official/nlp/bert/tokenization_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert/tokenization_test.py -------------------------------------------------------------------------------- /third/official/nlp/bert_modeling.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert_modeling.py -------------------------------------------------------------------------------- /third/official/nlp/bert_models.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/bert_models.py -------------------------------------------------------------------------------- /third/official/nlp/optimization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/optimization.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/README.md -------------------------------------------------------------------------------- /third/official/nlp/xlnet/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/official/nlp/xlnet/classifier_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/classifier_utils.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/common_flags.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/common_flags.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/data_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/data_utils.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/optimization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/optimization.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/preprocess_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/preprocess_utils.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/run_classifier.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/run_classifier.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/run_pretrain.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/run_pretrain.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/run_squad.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/run_squad.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/squad_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/squad_utils.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet/training_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet/training_utils.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet_config.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet_config.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet_modeling.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet_modeling.py -------------------------------------------------------------------------------- /third/official/nlp/xlnet_modeling_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/nlp/xlnet_modeling_test.py -------------------------------------------------------------------------------- /third/official/r1/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/r1/boosted_trees/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/boosted_trees/README.md -------------------------------------------------------------------------------- /third/official/r1/boosted_trees/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/r1/boosted_trees/train_higgs.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/boosted_trees/train_higgs.py -------------------------------------------------------------------------------- /third/official/r1/resnet/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/README.md -------------------------------------------------------------------------------- /third/official/r1/resnet/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/r1/resnet/cifar10_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/cifar10_main.py -------------------------------------------------------------------------------- /third/official/r1/resnet/cifar10_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/cifar10_test.py -------------------------------------------------------------------------------- /third/official/r1/resnet/estimator_benchmark.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/estimator_benchmark.py -------------------------------------------------------------------------------- /third/official/r1/resnet/imagenet_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/imagenet_main.py -------------------------------------------------------------------------------- /third/official/r1/resnet/imagenet_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/imagenet_test.py -------------------------------------------------------------------------------- /third/official/r1/resnet/layer_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/layer_test.py -------------------------------------------------------------------------------- /third/official/r1/resnet/resnet_model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/resnet_model.py -------------------------------------------------------------------------------- /third/official/r1/resnet/resnet_run_loop.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/resnet/resnet_run_loop.py -------------------------------------------------------------------------------- /third/official/r1/utils/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/r1/utils/data/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/r1/utils/data/file_io.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/utils/data/file_io.py -------------------------------------------------------------------------------- /third/official/r1/utils/data/file_io_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/utils/data/file_io_test.py -------------------------------------------------------------------------------- /third/official/r1/utils/export.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/utils/export.py -------------------------------------------------------------------------------- /third/official/r1/utils/export_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/utils/export_test.py -------------------------------------------------------------------------------- /third/official/r1/wide_deep/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/wide_deep/README.md -------------------------------------------------------------------------------- /third/official/r1/wide_deep/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/r1/wide_deep/census_dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/wide_deep/census_dataset.py -------------------------------------------------------------------------------- /third/official/r1/wide_deep/census_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/wide_deep/census_main.py -------------------------------------------------------------------------------- /third/official/r1/wide_deep/census_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/wide_deep/census_test.py -------------------------------------------------------------------------------- /third/official/r1/wide_deep/movielens_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/wide_deep/movielens_main.py -------------------------------------------------------------------------------- /third/official/r1/wide_deep/movielens_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/r1/wide_deep/movielens_test.py -------------------------------------------------------------------------------- /third/official/recommendation/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/README.md -------------------------------------------------------------------------------- /third/official/recommendation/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/recommendation/constants.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/constants.py -------------------------------------------------------------------------------- /third/official/recommendation/data_pipeline.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/data_pipeline.py -------------------------------------------------------------------------------- /third/official/recommendation/data_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/data_test.py -------------------------------------------------------------------------------- /third/official/recommendation/movielens.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/movielens.py -------------------------------------------------------------------------------- /third/official/recommendation/ncf_common.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/ncf_common.py -------------------------------------------------------------------------------- /third/official/recommendation/ncf_keras_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/ncf_keras_main.py -------------------------------------------------------------------------------- /third/official/recommendation/ncf_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/ncf_test.py -------------------------------------------------------------------------------- /third/official/recommendation/neumf_model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/neumf_model.py -------------------------------------------------------------------------------- /third/official/recommendation/popen_helper.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/popen_helper.py -------------------------------------------------------------------------------- /third/official/recommendation/run.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/run.sh -------------------------------------------------------------------------------- /third/official/recommendation/run_tpu.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/run_tpu.sh -------------------------------------------------------------------------------- /third/official/recommendation/stat_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/recommendation/stat_utils.py -------------------------------------------------------------------------------- /third/official/resnet/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/resnet/README.md -------------------------------------------------------------------------------- /third/official/resnet/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/resnet/__init__.py -------------------------------------------------------------------------------- /third/official/resnet/ctl/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/resnet/ctl/ctl_common.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/resnet/ctl/ctl_common.py -------------------------------------------------------------------------------- /third/official/resnet/ctl/ctl_imagenet_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/resnet/ctl/ctl_imagenet_main.py -------------------------------------------------------------------------------- /third/official/resnet/ctl/ctl_imagenet_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/resnet/ctl/ctl_imagenet_test.py -------------------------------------------------------------------------------- /third/official/staging/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/staging/shakespeare/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/staging/shakespeare/README.md -------------------------------------------------------------------------------- /third/official/staging/shakespeare/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/official/transformer/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/README.md -------------------------------------------------------------------------------- /third/official/transformer/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/transformer/compute_bleu.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/compute_bleu.py -------------------------------------------------------------------------------- /third/official/transformer/compute_bleu_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/compute_bleu_test.py -------------------------------------------------------------------------------- /third/official/transformer/data_download.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/data_download.py -------------------------------------------------------------------------------- /third/official/transformer/model/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/transformer/model/beam_search.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/model/beam_search.py -------------------------------------------------------------------------------- /third/official/transformer/model/ffn_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/model/ffn_layer.py -------------------------------------------------------------------------------- /third/official/transformer/model/model_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/model/model_utils.py -------------------------------------------------------------------------------- /third/official/transformer/model/transformer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/model/transformer.py -------------------------------------------------------------------------------- /third/official/transformer/transformer_main.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/transformer_main.py -------------------------------------------------------------------------------- /third/official/transformer/translate.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/translate.py -------------------------------------------------------------------------------- /third/official/transformer/utils/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/transformer/utils/dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/utils/dataset.py -------------------------------------------------------------------------------- /third/official/transformer/utils/metrics.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/utils/metrics.py -------------------------------------------------------------------------------- /third/official/transformer/utils/schedule.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/utils/schedule.py -------------------------------------------------------------------------------- /third/official/transformer/utils/tokenizer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/utils/tokenizer.py -------------------------------------------------------------------------------- /third/official/transformer/v2/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/README.md -------------------------------------------------------------------------------- /third/official/transformer/v2/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/transformer/v2/beam_search.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/beam_search.py -------------------------------------------------------------------------------- /third/official/transformer/v2/data_pipeline.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/data_pipeline.py -------------------------------------------------------------------------------- /third/official/transformer/v2/ffn_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/ffn_layer.py -------------------------------------------------------------------------------- /third/official/transformer/v2/metrics.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/metrics.py -------------------------------------------------------------------------------- /third/official/transformer/v2/misc.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/misc.py -------------------------------------------------------------------------------- /third/official/transformer/v2/optimizer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/optimizer.py -------------------------------------------------------------------------------- /third/official/transformer/v2/transformer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/transformer.py -------------------------------------------------------------------------------- /third/official/transformer/v2/translate.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/transformer/v2/translate.py -------------------------------------------------------------------------------- /third/official/utils/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/utils/accelerator/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/utils/accelerator/tpu.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/accelerator/tpu.py -------------------------------------------------------------------------------- /third/official/utils/accelerator/tpu_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/accelerator/tpu_test.py -------------------------------------------------------------------------------- /third/official/utils/flags/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/README.md -------------------------------------------------------------------------------- /third/official/utils/flags/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/utils/flags/_base.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_base.py -------------------------------------------------------------------------------- /third/official/utils/flags/_benchmark.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_benchmark.py -------------------------------------------------------------------------------- /third/official/utils/flags/_conventions.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_conventions.py -------------------------------------------------------------------------------- /third/official/utils/flags/_device.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_device.py -------------------------------------------------------------------------------- /third/official/utils/flags/_distribution.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_distribution.py -------------------------------------------------------------------------------- /third/official/utils/flags/_misc.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_misc.py -------------------------------------------------------------------------------- /third/official/utils/flags/_performance.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/_performance.py -------------------------------------------------------------------------------- /third/official/utils/flags/core.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/core.py -------------------------------------------------------------------------------- /third/official/utils/flags/flags_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/flags_test.py -------------------------------------------------------------------------------- /third/official/utils/flags/guidelines.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/flags/guidelines.md -------------------------------------------------------------------------------- /third/official/utils/logs/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/utils/logs/cloud_lib.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/cloud_lib.py -------------------------------------------------------------------------------- /third/official/utils/logs/cloud_lib_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/cloud_lib_test.py -------------------------------------------------------------------------------- /third/official/utils/logs/guidelines.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/guidelines.md -------------------------------------------------------------------------------- /third/official/utils/logs/hooks.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/hooks.py -------------------------------------------------------------------------------- /third/official/utils/logs/hooks_helper.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/hooks_helper.py -------------------------------------------------------------------------------- /third/official/utils/logs/hooks_helper_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/hooks_helper_test.py -------------------------------------------------------------------------------- /third/official/utils/logs/hooks_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/hooks_test.py -------------------------------------------------------------------------------- /third/official/utils/logs/logger.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/logger.py -------------------------------------------------------------------------------- /third/official/utils/logs/logger_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/logger_test.py -------------------------------------------------------------------------------- /third/official/utils/logs/metric_hook.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/metric_hook.py -------------------------------------------------------------------------------- /third/official/utils/logs/metric_hook_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/metric_hook_test.py -------------------------------------------------------------------------------- /third/official/utils/logs/mlperf_helper.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/logs/mlperf_helper.py -------------------------------------------------------------------------------- /third/official/utils/misc/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/utils/misc/callstack_sampler.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/misc/callstack_sampler.py -------------------------------------------------------------------------------- /third/official/utils/misc/distribution_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/misc/distribution_utils.py -------------------------------------------------------------------------------- /third/official/utils/misc/keras_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/misc/keras_utils.py -------------------------------------------------------------------------------- /third/official/utils/misc/model_helpers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/misc/model_helpers.py -------------------------------------------------------------------------------- /third/official/utils/misc/model_helpers_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/misc/model_helpers_test.py -------------------------------------------------------------------------------- /third/official/utils/misc/tpu_lib.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/misc/tpu_lib.py -------------------------------------------------------------------------------- /third/official/utils/testing/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/utils/testing/integration.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/testing/integration.py -------------------------------------------------------------------------------- /third/official/utils/testing/mock_lib.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/testing/mock_lib.py -------------------------------------------------------------------------------- /third/official/utils/testing/pylint.rcfile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/testing/pylint.rcfile -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/official/utils/testing/reference_data.py -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/reference_data_test/dense/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180325", "v1.7.0-rc1-750-g6c1737e6c8"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/reference_data_test/uniform_random/results.json: -------------------------------------------------------------------------------- 1 | [0.9872556924819946] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/reference_data_test/uniform_random/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180325", "v1.7.0-rc1-750-g6c1737e6c8"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch-size-32_bottleneck_version-1_width-8_channels-4/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch-size-32_bottleneck_version-2_width-8_channels-4/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch-size-32_building_projection_version-1_width-8_channels-4/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch-size-32_building_projection_version-2_width-8_channels-4/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch-size-32_building_version-1_width-8_channels-4/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch-size-32_building_version-2_width-8_channels-4/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/utils/testing/reference_data/resnet/batch_norm/tf_version.json: -------------------------------------------------------------------------------- 1 | ["1.8.0-dev20180408", "v1.7.0-1345-gb874783ccd"] -------------------------------------------------------------------------------- /third/official/vision/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/official/vision/image_classification/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/orbit/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/LICENSE -------------------------------------------------------------------------------- /third/orbit/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/README.md -------------------------------------------------------------------------------- /third/orbit/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/__init__.py -------------------------------------------------------------------------------- /third/orbit/controller.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/controller.py -------------------------------------------------------------------------------- /third/orbit/controller_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/controller_test.py -------------------------------------------------------------------------------- /third/orbit/runner.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/runner.py -------------------------------------------------------------------------------- /third/orbit/standard_runner.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/standard_runner.py -------------------------------------------------------------------------------- /third/orbit/standard_runner_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/standard_runner_test.py -------------------------------------------------------------------------------- /third/orbit/utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/__init__.py -------------------------------------------------------------------------------- /third/orbit/utils/common.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/common.py -------------------------------------------------------------------------------- /third/orbit/utils/common_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/common_test.py -------------------------------------------------------------------------------- /third/orbit/utils/epoch_helper.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/epoch_helper.py -------------------------------------------------------------------------------- /third/orbit/utils/loop_fns.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/loop_fns.py -------------------------------------------------------------------------------- /third/orbit/utils/summary_manager.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/summary_manager.py -------------------------------------------------------------------------------- /third/orbit/utils/tpu_summaries.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/tpu_summaries.py -------------------------------------------------------------------------------- /third/orbit/utils/tpu_summaries_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/orbit/utils/tpu_summaries_test.py -------------------------------------------------------------------------------- /third/reco_utils/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/README.md -------------------------------------------------------------------------------- /third/reco_utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/__init__.py -------------------------------------------------------------------------------- /third/reco_utils/azureml/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/azureml/aks_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/azureml/aks_utils.py -------------------------------------------------------------------------------- /third/reco_utils/azureml/azureml_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/azureml/azureml_utils.py -------------------------------------------------------------------------------- /third/reco_utils/azureml/svd_training.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/azureml/svd_training.py -------------------------------------------------------------------------------- /third/reco_utils/azureml/wide_deep_training.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/azureml/wide_deep_training.py -------------------------------------------------------------------------------- /third/reco_utils/common/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/common/constants.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/constants.py -------------------------------------------------------------------------------- /third/reco_utils/common/general_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/general_utils.py -------------------------------------------------------------------------------- /third/reco_utils/common/gpu_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/gpu_utils.py -------------------------------------------------------------------------------- /third/reco_utils/common/notebook_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/notebook_utils.py -------------------------------------------------------------------------------- /third/reco_utils/common/plot.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/plot.py -------------------------------------------------------------------------------- /third/reco_utils/common/python_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/python_utils.py -------------------------------------------------------------------------------- /third/reco_utils/common/spark_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/spark_utils.py -------------------------------------------------------------------------------- /third/reco_utils/common/tf_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/tf_utils.py -------------------------------------------------------------------------------- /third/reco_utils/common/timer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/common/timer.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/dataset/amazon_reviews.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/amazon_reviews.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/blob_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/blob_utils.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/cosmos_cli.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/cosmos_cli.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/covid_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/covid_utils.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/criteo.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/criteo.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/download_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/download_utils.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/mind.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/mind.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/movielens.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/movielens.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/pandas_df_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/pandas_df_utils.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/python_splitters.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/python_splitters.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/spark_splitters.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/spark_splitters.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/sparse.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/sparse.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/split_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/split_utils.py -------------------------------------------------------------------------------- /third/reco_utils/dataset/wikidata.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/dataset/wikidata.py -------------------------------------------------------------------------------- /third/reco_utils/evaluation/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/evaluation/spark_evaluation.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/evaluation/spark_evaluation.py -------------------------------------------------------------------------------- /third/reco_utils/recommender/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/cornac/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/deeprec/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/deeprec/io/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/deeprec/models/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/fastai/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/geoimc/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/lightfm/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/lightgbm/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/ncf/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/ncf/dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/recommender/ncf/dataset.py -------------------------------------------------------------------------------- /third/reco_utils/recommender/newsrec/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/newsrec/io/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/newsrec/models/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/rbm/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/rbm/rbm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/recommender/rbm/rbm.py -------------------------------------------------------------------------------- /third/reco_utils/recommender/rlrmc/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/sar/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/recommender/sar/__init__.py -------------------------------------------------------------------------------- /third/reco_utils/recommender/surprise/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/tfidf/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/vowpal_wabbit/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/reco_utils/recommender/wide_deep/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/reco_utils/tuning/__init__.py: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /third/reco_utils/tuning/nni/ncf_training.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/tuning/nni/ncf_training.py -------------------------------------------------------------------------------- /third/reco_utils/tuning/nni/ncf_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/tuning/nni/ncf_utils.py -------------------------------------------------------------------------------- /third/reco_utils/tuning/nni/nni_utils.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/tuning/nni/nni_utils.py -------------------------------------------------------------------------------- /third/reco_utils/tuning/nni/svd_training.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/tuning/nni/svd_training.py -------------------------------------------------------------------------------- /third/reco_utils/tuning/parameter_sweep.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/reco_utils/tuning/parameter_sweep.py -------------------------------------------------------------------------------- /third/sentencepiece/CONTRIBUTING.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/CONTRIBUTING.md -------------------------------------------------------------------------------- /third/sentencepiece/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/LICENSE -------------------------------------------------------------------------------- /third/sentencepiece/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/README.md -------------------------------------------------------------------------------- /third/sentencepiece/appveyor.yml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/appveyor.yml -------------------------------------------------------------------------------- /third/sentencepiece/config.h.in: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/config.h.in -------------------------------------------------------------------------------- /third/sentencepiece/data/extract_headers.pl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/extract_headers.pl -------------------------------------------------------------------------------- /third/sentencepiece/data/gen_spec_parser.pl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/gen_spec_parser.pl -------------------------------------------------------------------------------- /third/sentencepiece/data/ids_denorm.tsv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/ids_denorm.tsv -------------------------------------------------------------------------------- /third/sentencepiece/data/ids_norm.tsv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/ids_norm.tsv -------------------------------------------------------------------------------- /third/sentencepiece/data/nfkc.tsv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/nfkc.tsv -------------------------------------------------------------------------------- /third/sentencepiece/data/nfkc_cf.tsv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/nfkc_cf.tsv -------------------------------------------------------------------------------- /third/sentencepiece/data/nmt_nfkc.tsv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/nmt_nfkc.tsv -------------------------------------------------------------------------------- /third/sentencepiece/data/nmt_nfkc_cf.tsv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/data/nmt_nfkc_cf.tsv -------------------------------------------------------------------------------- /third/sentencepiece/doc/api.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/doc/api.md -------------------------------------------------------------------------------- /third/sentencepiece/doc/experiments.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/doc/experiments.md -------------------------------------------------------------------------------- /third/sentencepiece/doc/normalization.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/doc/normalization.md -------------------------------------------------------------------------------- /third/sentencepiece/doc/options.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/doc/options.md -------------------------------------------------------------------------------- /third/sentencepiece/doc/special_symbols.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/doc/special_symbols.md -------------------------------------------------------------------------------- /third/sentencepiece/python/MANIFEST.in: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/MANIFEST.in -------------------------------------------------------------------------------- /third/sentencepiece/python/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/README.md -------------------------------------------------------------------------------- /third/sentencepiece/python/add_new_vocab.ipynb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/add_new_vocab.ipynb -------------------------------------------------------------------------------- /third/sentencepiece/python/build_bundled.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/build_bundled.sh -------------------------------------------------------------------------------- /third/sentencepiece/python/make_py_wheel.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/make_py_wheel.sh -------------------------------------------------------------------------------- /third/sentencepiece/python/make_py_wheel_mac.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/make_py_wheel_mac.sh -------------------------------------------------------------------------------- /third/sentencepiece/python/once.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/once.h -------------------------------------------------------------------------------- /third/sentencepiece/python/setup.cfg: -------------------------------------------------------------------------------- 1 | [metadata] 2 | description-file = README.md 3 | -------------------------------------------------------------------------------- /third/sentencepiece/python/setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/python/setup.py -------------------------------------------------------------------------------- /third/sentencepiece/python/test/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /third/sentencepiece/sentencepiece.pc.in: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/sentencepiece.pc.in -------------------------------------------------------------------------------- /third/sentencepiece/src/bpe_model.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/bpe_model.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/bpe_model.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/bpe_model.h -------------------------------------------------------------------------------- /third/sentencepiece/src/bpe_model_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/bpe_model_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/bpe_model_trainer.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/bpe_model_trainer.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/bpe_model_trainer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/bpe_model_trainer.h -------------------------------------------------------------------------------- /third/sentencepiece/src/builder.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/builder.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/builder.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/builder.h -------------------------------------------------------------------------------- /third/sentencepiece/src/builder_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/builder_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/char_model.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/char_model.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/char_model.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/char_model.h -------------------------------------------------------------------------------- /third/sentencepiece/src/char_model_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/char_model_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/char_model_trainer.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/char_model_trainer.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/char_model_trainer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/char_model_trainer.h -------------------------------------------------------------------------------- /third/sentencepiece/src/common.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/common.h -------------------------------------------------------------------------------- /third/sentencepiece/src/error.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/error.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/filesystem.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/filesystem.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/filesystem.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/filesystem.h -------------------------------------------------------------------------------- /third/sentencepiece/src/filesystem_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/filesystem_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/freelist.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/freelist.h -------------------------------------------------------------------------------- /third/sentencepiece/src/freelist_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/freelist_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/init.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/init.h -------------------------------------------------------------------------------- /third/sentencepiece/src/init_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/init_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/model_factory.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/model_factory.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/model_factory.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/model_factory.h -------------------------------------------------------------------------------- /third/sentencepiece/src/model_factory_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/model_factory_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/model_interface.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/model_interface.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/model_interface.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/model_interface.h -------------------------------------------------------------------------------- /third/sentencepiece/src/model_interface_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/model_interface_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/normalization_rule.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/normalization_rule.h -------------------------------------------------------------------------------- /third/sentencepiece/src/normalizer.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/normalizer.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/normalizer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/normalizer.h -------------------------------------------------------------------------------- /third/sentencepiece/src/normalizer_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/normalizer_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/sentencepiece.proto: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/sentencepiece.proto -------------------------------------------------------------------------------- /third/sentencepiece/src/sentencepiece_trainer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/sentencepiece_trainer.h -------------------------------------------------------------------------------- /third/sentencepiece/src/spec_parser.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/spec_parser.h -------------------------------------------------------------------------------- /third/sentencepiece/src/spm_decode_main.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/spm_decode_main.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/spm_encode_main.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/spm_encode_main.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/spm_train_main.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/spm_train_main.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/test_main.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/test_main.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/testharness.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/testharness.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/testharness.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/testharness.h -------------------------------------------------------------------------------- /third/sentencepiece/src/trainer_factory.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/trainer_factory.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/trainer_factory.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/trainer_factory.h -------------------------------------------------------------------------------- /third/sentencepiece/src/trainer_interface.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/trainer_interface.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/trainer_interface.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/trainer_interface.h -------------------------------------------------------------------------------- /third/sentencepiece/src/unicode_script.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/unicode_script.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/unicode_script.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/unicode_script.h -------------------------------------------------------------------------------- /third/sentencepiece/src/unicode_script_map.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/unicode_script_map.h -------------------------------------------------------------------------------- /third/sentencepiece/src/unigram_model.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/unigram_model.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/unigram_model.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/unigram_model.h -------------------------------------------------------------------------------- /third/sentencepiece/src/util.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/util.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/util.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/util.h -------------------------------------------------------------------------------- /third/sentencepiece/src/util_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/util_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/word_model.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/word_model.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/word_model.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/word_model.h -------------------------------------------------------------------------------- /third/sentencepiece/src/word_model_test.cc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/word_model_test.cc -------------------------------------------------------------------------------- /third/sentencepiece/src/word_model_trainer.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/src/word_model_trainer.h -------------------------------------------------------------------------------- /third/sentencepiece/tensorflow/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/tensorflow/README.md -------------------------------------------------------------------------------- /third/sentencepiece/test.bat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/test.bat -------------------------------------------------------------------------------- /third/sentencepiece/test.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/test.sh -------------------------------------------------------------------------------- /third/sentencepiece/third_party/absl/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/sentencepiece/third_party/absl/LICENSE -------------------------------------------------------------------------------- /third/tensorflow_examples/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_examples/__init__.py -------------------------------------------------------------------------------- /third/tensorflow_examples/lite/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_examples/lite/__init__.py -------------------------------------------------------------------------------- /third/tensorflow_examples/lite/model_maker/core/task/testdata/hub_module_v1_mini/tfhub_module.pb: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /third/tensorflow_examples/lite/model_maker/core/task/testdata/hub_module_v1_mini_train/tfhub_module.pb: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /third/tensorflow_examples/models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_examples/models/__init__.py -------------------------------------------------------------------------------- /third/tensorflow_recommenders/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/BUILD -------------------------------------------------------------------------------- /third/tensorflow_recommenders/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/__init__.py -------------------------------------------------------------------------------- /third/tensorflow_recommenders/examples/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/examples/BUILD -------------------------------------------------------------------------------- /third/tensorflow_recommenders/layers/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/layers/BUILD -------------------------------------------------------------------------------- /third/tensorflow_recommenders/layers/loss.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/layers/loss.py -------------------------------------------------------------------------------- /third/tensorflow_recommenders/metrics/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/metrics/BUILD -------------------------------------------------------------------------------- /third/tensorflow_recommenders/models/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/models/BUILD -------------------------------------------------------------------------------- /third/tensorflow_recommenders/models/base.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/models/base.py -------------------------------------------------------------------------------- /third/tensorflow_recommenders/tasks/BUILD: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/tasks/BUILD -------------------------------------------------------------------------------- /third/tensorflow_recommenders/tasks/base.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/tasks/base.py -------------------------------------------------------------------------------- /third/tensorflow_recommenders/types.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/tensorflow_recommenders/types.py -------------------------------------------------------------------------------- /third/wandb/redirect.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/wandb/redirect.py -------------------------------------------------------------------------------- /third/weighted_boxes_fusion/CHANGES.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/weighted_boxes_fusion/CHANGES.md -------------------------------------------------------------------------------- /third/weighted_boxes_fusion/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/weighted_boxes_fusion/LICENSE -------------------------------------------------------------------------------- /third/weighted_boxes_fusion/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/weighted_boxes_fusion/README.md -------------------------------------------------------------------------------- /third/weighted_boxes_fusion/setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/third/weighted_boxes_fusion/setup.py -------------------------------------------------------------------------------- /utils/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/README.md -------------------------------------------------------------------------------- /utils/gezi/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/__init__.py -------------------------------------------------------------------------------- /utils/gezi/avg_score.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/avg_score.py -------------------------------------------------------------------------------- /utils/gezi/bigdata_util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/bigdata_util.py -------------------------------------------------------------------------------- /utils/gezi/bleu.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/gezi/common.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/common.py -------------------------------------------------------------------------------- /utils/gezi/geneticalgorithm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/geneticalgorithm.py -------------------------------------------------------------------------------- /utils/gezi/gezi_util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/gezi_util.py -------------------------------------------------------------------------------- /utils/gezi/hash.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/hash.py -------------------------------------------------------------------------------- /utils/gezi/libgezi_util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/libgezi_util.py -------------------------------------------------------------------------------- /utils/gezi/melt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/melt/__init__.py -------------------------------------------------------------------------------- /utils/gezi/melt/tfrecords.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/melt/tfrecords.py -------------------------------------------------------------------------------- /utils/gezi/melt/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/melt/util.py -------------------------------------------------------------------------------- /utils/gezi/metrics/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/README.md -------------------------------------------------------------------------------- /utils/gezi/metrics/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/bleu/LICENSE: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/bleu/LICENSE -------------------------------------------------------------------------------- /utils/gezi/metrics/bleu/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/bleu/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/bleu/bleu.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/bleu/bleu.py -------------------------------------------------------------------------------- /utils/gezi/metrics/bleu/bleu_scorer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/bleu/bleu_scorer.py -------------------------------------------------------------------------------- /utils/gezi/metrics/cider/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/cider/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/cider/cider.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/cider/cider.py -------------------------------------------------------------------------------- /utils/gezi/metrics/cider/cider_scorer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/cider/cider_scorer.py -------------------------------------------------------------------------------- /utils/gezi/metrics/ciderD/__init__.py: -------------------------------------------------------------------------------- 1 | __author__ = 'tylin' 2 | -------------------------------------------------------------------------------- /utils/gezi/metrics/ciderD/ciderD.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/ciderD/ciderD.py -------------------------------------------------------------------------------- /utils/gezi/metrics/ciderD/ciderD_scorer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/ciderD/ciderD_scorer.py -------------------------------------------------------------------------------- /utils/gezi/metrics/correlation/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/correlation/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/eval.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/gezi/metrics/image/__init__.py: -------------------------------------------------------------------------------- 1 | import gezi.metrics.image.semantic_seg -------------------------------------------------------------------------------- /utils/gezi/metrics/image/semantic_seg.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/image/semantic_seg.py -------------------------------------------------------------------------------- /utils/gezi/metrics/meteor/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/meteor/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/meteor/meteor-1.5.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/meteor/meteor-1.5.jar -------------------------------------------------------------------------------- /utils/gezi/metrics/meteor/meteor.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/meteor/meteor.py -------------------------------------------------------------------------------- /utils/gezi/metrics/metrics.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/metrics.py -------------------------------------------------------------------------------- /utils/gezi/metrics/ner.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/ner.py -------------------------------------------------------------------------------- /utils/gezi/metrics/new_cider/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/new_cider/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/new_cider/cider.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/new_cider/cider.py -------------------------------------------------------------------------------- /utils/gezi/metrics/new_cider/cider_scorer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/new_cider/cider_scorer.py -------------------------------------------------------------------------------- /utils/gezi/metrics/rouge/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/rouge/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/rouge/rouge.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/rouge/rouge.py -------------------------------------------------------------------------------- /utils/gezi/metrics/stats/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/gezi/metrics/stats/_stats.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/stats/_stats.c -------------------------------------------------------------------------------- /utils/gezi/metrics/stats/_stats.pyx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/stats/_stats.pyx -------------------------------------------------------------------------------- /utils/gezi/metrics/stats/build.sh: -------------------------------------------------------------------------------- 1 | python setup.py build_ext --inplace 2 | -------------------------------------------------------------------------------- /utils/gezi/metrics/stats/setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/stats/setup.py -------------------------------------------------------------------------------- /utils/gezi/metrics/tokenizer/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/tokenizer/__init__.py -------------------------------------------------------------------------------- /utils/gezi/metrics/tokenizer/ptbtokenizer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/metrics/tokenizer/ptbtokenizer.py -------------------------------------------------------------------------------- /utils/gezi/ngram.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/ngram.py -------------------------------------------------------------------------------- /utils/gezi/nowarning.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/nowarning.py -------------------------------------------------------------------------------- /utils/gezi/plot.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/plot.py -------------------------------------------------------------------------------- /utils/gezi/pydict.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/pydict.py -------------------------------------------------------------------------------- /utils/gezi/rank_metrics.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/rank_metrics.py -------------------------------------------------------------------------------- /utils/gezi/segment.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/segment.py -------------------------------------------------------------------------------- /utils/gezi/setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/setup.py -------------------------------------------------------------------------------- /utils/gezi/summary.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/summary.py -------------------------------------------------------------------------------- /utils/gezi/test/test_get_single_cn.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/gezi/test/test_ngrams.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/test/test_ngrams.py -------------------------------------------------------------------------------- /utils/gezi/timer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/timer.py -------------------------------------------------------------------------------- /utils/gezi/topn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/topn.py -------------------------------------------------------------------------------- /utils/gezi/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/util.py -------------------------------------------------------------------------------- /utils/gezi/utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/utils/__init__.py -------------------------------------------------------------------------------- /utils/gezi/utils/logging.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/utils/logging.py -------------------------------------------------------------------------------- /utils/gezi/vocabulary.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/vocabulary.py -------------------------------------------------------------------------------- /utils/gezi/word_counter.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/word_counter.py -------------------------------------------------------------------------------- /utils/gezi/zhtools/Mandarin.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/zhtools/Mandarin.dat -------------------------------------------------------------------------------- /utils/gezi/zhtools/__init__.py: -------------------------------------------------------------------------------- 1 | from gezi.zhtools import langconv 2 | -------------------------------------------------------------------------------- /utils/gezi/zhtools/chconv.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/zhtools/chconv.py -------------------------------------------------------------------------------- /utils/gezi/zhtools/langconv.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/zhtools/langconv.py -------------------------------------------------------------------------------- /utils/gezi/zhtools/test_langconv.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/zhtools/test_langconv.py -------------------------------------------------------------------------------- /utils/gezi/zhtools/xpinyin.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/zhtools/xpinyin.py -------------------------------------------------------------------------------- /utils/gezi/zhtools/zh_wiki.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/gezi/zhtools/zh_wiki.py -------------------------------------------------------------------------------- /utils/husky/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/__init__.py -------------------------------------------------------------------------------- /utils/husky/callbacks/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/callbacks/__init__.py -------------------------------------------------------------------------------- /utils/husky/callbacks/callbacks.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/callbacks/callbacks.py -------------------------------------------------------------------------------- /utils/husky/callbacks/evaluate.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/callbacks/evaluate.py -------------------------------------------------------------------------------- /utils/husky/callbacks/swa.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/callbacks/swa.py -------------------------------------------------------------------------------- /utils/husky/callbacks/tqdm_progress_bar.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/callbacks/tqdm_progress_bar.py -------------------------------------------------------------------------------- /utils/husky/ema.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/ema.py -------------------------------------------------------------------------------- /utils/husky/optimization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/optimization.py -------------------------------------------------------------------------------- /utils/husky/train.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/husky/train.py -------------------------------------------------------------------------------- /utils/lele/README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /utils/lele/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/__init__.py -------------------------------------------------------------------------------- /utils/lele/apps/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/lele/apps/train.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/apps/train.py -------------------------------------------------------------------------------- /utils/lele/distributed/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/lele/distributed/parallel.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/distributed/parallel.py -------------------------------------------------------------------------------- /utils/lele/fastai/__init__.py: -------------------------------------------------------------------------------- 1 | import lele.fastai.text 2 | 3 | -------------------------------------------------------------------------------- /utils/lele/fastai/core.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/core.py -------------------------------------------------------------------------------- /utils/lele/fastai/imports/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/imports/__init__.py -------------------------------------------------------------------------------- /utils/lele/fastai/imports/core.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/imports/core.py -------------------------------------------------------------------------------- /utils/lele/fastai/imports/torch.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/imports/torch.py -------------------------------------------------------------------------------- /utils/lele/fastai/layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/layers.py -------------------------------------------------------------------------------- /utils/lele/fastai/text/__init__.py: -------------------------------------------------------------------------------- 1 | from lele.fastai.text.models import * -------------------------------------------------------------------------------- /utils/lele/fastai/text/models.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/text/models.py -------------------------------------------------------------------------------- /utils/lele/fastai/text/qrnn/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/lele/fastai/text/qrnn/forget_mult.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/text/qrnn/forget_mult.py -------------------------------------------------------------------------------- /utils/lele/fastai/text/qrnn/qrnn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/text/qrnn/qrnn.py -------------------------------------------------------------------------------- /utils/lele/fastai/torch_core.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/fastai/torch_core.py -------------------------------------------------------------------------------- /utils/lele/layers/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/README.md -------------------------------------------------------------------------------- /utils/lele/layers/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/__init__.py -------------------------------------------------------------------------------- /utils/lele/layers/activation.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/activation.py -------------------------------------------------------------------------------- /utils/lele/layers/classify_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/classify_layer.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/__init__.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/classify_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/classify_layer.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/elmo.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/elmo.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/embedding_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/embedding_layer.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/encoder_base.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/encoder_base.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/highway.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/highway.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/lstm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/lstm.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/token_embedder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/token_embedder.py -------------------------------------------------------------------------------- /utils/lele/layers/elmo/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/elmo/util.py -------------------------------------------------------------------------------- /utils/lele/layers/embedding_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/embedding_layer.py -------------------------------------------------------------------------------- /utils/lele/layers/encoder_base.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/encoder_base.py -------------------------------------------------------------------------------- /utils/lele/layers/hash_embedding.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/hash_embedding.py -------------------------------------------------------------------------------- /utils/lele/layers/highway.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/highway.py -------------------------------------------------------------------------------- /utils/lele/layers/large_embedding.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/large_embedding.py -------------------------------------------------------------------------------- /utils/lele/layers/layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/layers.py -------------------------------------------------------------------------------- /utils/lele/layers/lstm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/lstm.py -------------------------------------------------------------------------------- /utils/lele/layers/token_embedder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/token_embedder.py -------------------------------------------------------------------------------- /utils/lele/layers/transformer/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/transformer/__init__.py -------------------------------------------------------------------------------- /utils/lele/layers/transformer/transformer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/transformer/transformer.py -------------------------------------------------------------------------------- /utils/lele/layers/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/layers/util.py -------------------------------------------------------------------------------- /utils/lele/losses/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/losses/__init__.py -------------------------------------------------------------------------------- /utils/lele/losses/losses.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/losses/losses.py -------------------------------------------------------------------------------- /utils/lele/losses/lovasz.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/losses/lovasz.py -------------------------------------------------------------------------------- /utils/lele/nlp/pretrain/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/nlp/pretrain/README.md -------------------------------------------------------------------------------- /utils/lele/nlp/pretrain/mlm.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/nlp/pretrain/mlm.py -------------------------------------------------------------------------------- /utils/lele/nlp/pretrain/rtd.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/nlp/pretrain/rtd.py -------------------------------------------------------------------------------- /utils/lele/ops/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/ops/__init__.py -------------------------------------------------------------------------------- /utils/lele/ops/ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/ops/ops.py -------------------------------------------------------------------------------- /utils/lele/training/__init__.py: -------------------------------------------------------------------------------- 1 | import lele.training.optimizers 2 | -------------------------------------------------------------------------------- /utils/lele/training/optimizers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/training/optimizers.py -------------------------------------------------------------------------------- /utils/lele/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/lele/util.py -------------------------------------------------------------------------------- /utils/melt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/__init__.py -------------------------------------------------------------------------------- /utils/melt/apps/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/apps/__init__.py -------------------------------------------------------------------------------- /utils/melt/apps/config.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/apps/config.py -------------------------------------------------------------------------------- /utils/melt/apps/image_processing.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/apps/image_processing.py -------------------------------------------------------------------------------- /utils/melt/apps/init.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/apps/init.py -------------------------------------------------------------------------------- /utils/melt/apps/train.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/apps/train.py -------------------------------------------------------------------------------- /utils/melt/cnn/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/cnn/__init__.py -------------------------------------------------------------------------------- /utils/melt/cnn/cnn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/cnn/cnn.py -------------------------------------------------------------------------------- /utils/melt/cnn/conv2d.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/cnn/conv2d.py -------------------------------------------------------------------------------- /utils/melt/cnn/qanet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/cnn/qanet.py -------------------------------------------------------------------------------- /utils/melt/deepctr/__init__.py: -------------------------------------------------------------------------------- 1 | import melt.deepctr.layers 2 | -------------------------------------------------------------------------------- /utils/melt/deepctr/layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/deepctr/layers.py -------------------------------------------------------------------------------- /utils/melt/distributed/__init__.py: -------------------------------------------------------------------------------- 1 | from melt.distributed.util import * 2 | -------------------------------------------------------------------------------- /utils/melt/distributed/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/distributed/util.py -------------------------------------------------------------------------------- /utils/melt/eager/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/eager/__init__.py -------------------------------------------------------------------------------- /utils/melt/eager/train.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/eager/train.py -------------------------------------------------------------------------------- /utils/melt/eager/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/eager/util.py -------------------------------------------------------------------------------- /utils/melt/encoder/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/encoder/__init__.py -------------------------------------------------------------------------------- /utils/melt/encoder/embedding_layer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/encoder/embedding_layer.py -------------------------------------------------------------------------------- /utils/melt/encoder/transformer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/encoder/transformer.py -------------------------------------------------------------------------------- /utils/melt/flow/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/flow/__init__.py -------------------------------------------------------------------------------- /utils/melt/flow/flow.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/flow/flow.py -------------------------------------------------------------------------------- /utils/melt/flow/test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/flow/test.py -------------------------------------------------------------------------------- /utils/melt/flow/test_once.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/flow/test_once.py -------------------------------------------------------------------------------- /utils/melt/flow/train.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/flow/train.py -------------------------------------------------------------------------------- /utils/melt/flow/train_once.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/flow/train_once.py -------------------------------------------------------------------------------- /utils/melt/global_objectives/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/global_objectives/README.md -------------------------------------------------------------------------------- /utils/melt/global_objectives/__init__.py: -------------------------------------------------------------------------------- 1 | from melt.global_objectives.loss_layers import * 2 | -------------------------------------------------------------------------------- /utils/melt/global_objectives/loss_layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/global_objectives/loss_layers.py -------------------------------------------------------------------------------- /utils/melt/global_objectives/test_all.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/global_objectives/test_all.py -------------------------------------------------------------------------------- /utils/melt/global_objectives/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/global_objectives/util.py -------------------------------------------------------------------------------- /utils/melt/global_objectives/util_test.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/global_objectives/util_test.py -------------------------------------------------------------------------------- /utils/melt/image/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/image/__init__.py -------------------------------------------------------------------------------- /utils/melt/image/augment.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/image/augment.py -------------------------------------------------------------------------------- /utils/melt/image/image_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/image/image_decoder.py -------------------------------------------------------------------------------- /utils/melt/image/image_embedding.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/image/image_embedding.py -------------------------------------------------------------------------------- /utils/melt/image/image_model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/image/image_model.py -------------------------------------------------------------------------------- /utils/melt/image/image_processing.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/image/image_processing.py -------------------------------------------------------------------------------- /utils/melt/inference/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/inference/__init__.py -------------------------------------------------------------------------------- /utils/melt/inference/predictor.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/inference/predictor.py -------------------------------------------------------------------------------- /utils/melt/inference/predictor_base.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/melt/layers/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/__init__.py -------------------------------------------------------------------------------- /utils/melt/layers/cnn/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/cnn/__init__.py -------------------------------------------------------------------------------- /utils/melt/layers/cnn/cnn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/cnn/cnn.py -------------------------------------------------------------------------------- /utils/melt/layers/cnn/convnet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/cnn/convnet.py -------------------------------------------------------------------------------- /utils/melt/layers/cnn/qanet.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/cnn/qanet.py -------------------------------------------------------------------------------- /utils/melt/layers/layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/layers.py -------------------------------------------------------------------------------- /utils/melt/layers/optimizers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/optimizers.py -------------------------------------------------------------------------------- /utils/melt/layers/rnn/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/rnn/__init__.py -------------------------------------------------------------------------------- /utils/melt/layers/rnn/rnn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/rnn/rnn.py -------------------------------------------------------------------------------- /utils/melt/layers/transformer/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/transformer/__init__.py -------------------------------------------------------------------------------- /utils/melt/layers/transformer/transformer.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/layers/transformer/transformer.py -------------------------------------------------------------------------------- /utils/melt/losses/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/losses/__init__.py -------------------------------------------------------------------------------- /utils/melt/losses/losses.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/losses/losses.py -------------------------------------------------------------------------------- /utils/melt/metrics/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/metrics/__init__.py -------------------------------------------------------------------------------- /utils/melt/metrics/metrics.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/metrics/metrics.py -------------------------------------------------------------------------------- /utils/melt/metrics/rank_metrics.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/metrics/rank_metrics.py -------------------------------------------------------------------------------- /utils/melt/models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/models/__init__.py -------------------------------------------------------------------------------- /utils/melt/models/bert.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/models/bert.py -------------------------------------------------------------------------------- /utils/melt/models/mlp.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/models/mlp.py -------------------------------------------------------------------------------- /utils/melt/ops/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/ops/__init__.py -------------------------------------------------------------------------------- /utils/melt/ops/nn_impl.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/ops/nn_impl.py -------------------------------------------------------------------------------- /utils/melt/ops/ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/ops/ops.py -------------------------------------------------------------------------------- /utils/melt/ops/sparse_ops.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/ops/sparse_ops.py -------------------------------------------------------------------------------- /utils/melt/pretrain/__init__.py: -------------------------------------------------------------------------------- 1 | import melt.pretrain.bert 2 | -------------------------------------------------------------------------------- /utils/melt/pretrain/bert.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/pretrain/bert.py -------------------------------------------------------------------------------- /utils/melt/rnn/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/rnn/__init__.py -------------------------------------------------------------------------------- /utils/melt/rnn/rnn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/rnn/rnn.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/README.md -------------------------------------------------------------------------------- /utils/melt/seq2seq/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/__init__.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/attention_decoder_fn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/attention_decoder_fn.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/attention_wrapper.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/attention_wrapper.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/basic_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/basic_decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/beam_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/beam_decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/beam_decoder_fn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/beam_decoder_fn.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/beam_search.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/beam_search.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/beam_search_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/beam_search_decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/decoder_fn.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/decoder_fn.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/exp/beam_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/exp/beam_decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/helper.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/helper.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/legacy/beam_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/legacy/beam_decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/logprobs_decoder.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/logprobs_decoder.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/loss.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/loss.py -------------------------------------------------------------------------------- /utils/melt/seq2seq/seq2seq.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/seq2seq/seq2seq.py -------------------------------------------------------------------------------- /utils/melt/setup.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/setup.py -------------------------------------------------------------------------------- /utils/melt/slim2/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/slim2/__init__.py -------------------------------------------------------------------------------- /utils/melt/slim2/base_nets_factory.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/slim2/base_nets_factory.py -------------------------------------------------------------------------------- /utils/melt/slim2/layers.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/slim2/layers.py -------------------------------------------------------------------------------- /utils/melt/slim2/preprocessing_factory.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /utils/melt/tfrecords/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/__init__.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/dataset.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/dataset.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/dataset_decode.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/dataset_decode.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/decode_then_shuffle.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/decode_then_shuffle.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/libsvm_decode.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/libsvm_decode.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/read.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/read.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/shuffle_then_decode.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/shuffle_then_decode.py -------------------------------------------------------------------------------- /utils/melt/tfrecords/write.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tfrecords/write.py -------------------------------------------------------------------------------- /utils/melt/tools/checkpoint2pb.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/checkpoint2pb.py -------------------------------------------------------------------------------- /utils/melt/tools/checkpoint2savedmodel.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/checkpoint2savedmodel.py -------------------------------------------------------------------------------- /utils/melt/tools/count-records.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/count-records.py -------------------------------------------------------------------------------- /utils/melt/tools/delete-old-models.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/delete-old-models.py -------------------------------------------------------------------------------- /utils/melt/tools/prepare-finetune.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/prepare-finetune.py -------------------------------------------------------------------------------- /utils/melt/tools/rename-variables.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/rename-variables.py -------------------------------------------------------------------------------- /utils/melt/tools/reset-model-top-scope.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/reset-model-top-scope.py -------------------------------------------------------------------------------- /utils/melt/tools/show-records.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/show-records.py -------------------------------------------------------------------------------- /utils/melt/tools/show-var-of-model.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/tools/show-var-of-model.py -------------------------------------------------------------------------------- /utils/melt/torch/__init__.py: -------------------------------------------------------------------------------- 1 | from melt.torch.train import * 2 | -------------------------------------------------------------------------------- /utils/melt/torch/train.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/torch/train.py -------------------------------------------------------------------------------- /utils/melt/training/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/training/__init__.py -------------------------------------------------------------------------------- /utils/melt/training/adamax.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/training/adamax.py -------------------------------------------------------------------------------- /utils/melt/training/bert/__init__.py: -------------------------------------------------------------------------------- 1 | from melt.training.bert.optimization import * 2 | -------------------------------------------------------------------------------- /utils/melt/training/bert/optimization.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/training/bert/optimization.py -------------------------------------------------------------------------------- /utils/melt/training/learning_rate_decay.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/training/learning_rate_decay.py -------------------------------------------------------------------------------- /utils/melt/training/training.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/training/training.py -------------------------------------------------------------------------------- /utils/melt/util.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/util.py -------------------------------------------------------------------------------- /utils/melt/utils/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/utils/__init__.py -------------------------------------------------------------------------------- /utils/melt/utils/embsim.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/utils/embsim.py -------------------------------------------------------------------------------- /utils/melt/utils/summary.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/utils/summary.py -------------------------------------------------------------------------------- /utils/melt/utils/weight_decay.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/utils/weight_decay.py -------------------------------------------------------------------------------- /utils/melt/variable/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/variable/__init__.py -------------------------------------------------------------------------------- /utils/melt/variable/variable.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenghuige/U.S.-Patent-Phrase-to-Phrase-Matching/HEAD/utils/melt/variable/variable.py --------------------------------------------------------------------------------