├── .github ├── actions │ └── server-testing │ │ └── action.yml └── workflows │ ├── publish-to-test-pypi.yml │ ├── server_installer_windows_latest.yml │ ├── test_devices_plugin.yml │ ├── test_gpu_turnkey.yml │ ├── test_lemonade.yml │ ├── test_lemonade_oga_cpu.yml │ ├── test_quark.yml │ ├── test_server.yml │ ├── test_turnkey.yml │ └── test_turnkey_noop.yml ├── .lfsconfig ├── .pylintrc ├── LICENSE ├── NOTICE.md ├── README.md ├── docs ├── code.md ├── contribute.md ├── coverage.md ├── install.md ├── lemonade │ ├── README.md │ ├── humaneval_accuracy.md │ ├── lemonade_api.md │ ├── lemonade_server_exe.md │ ├── llamacpp.md │ ├── mmlu_accuracy.md │ ├── ort_genai_igpu.md │ ├── perplexity.md │ ├── quark.md │ ├── server_integration.md │ ├── server_models.md │ ├── server_spec.md │ └── source_installation_inst.md ├── readme.md ├── turnkey │ ├── README.md │ └── tools_user_guide.md └── versioning.md ├── examples ├── lemonade │ ├── README.md │ ├── api_basic.py │ ├── api_oga_cpu.py │ ├── api_oga_cpu_streaming.py │ ├── api_oga_hybrid.py │ ├── api_oga_hybrid_streaming.py │ ├── api_oga_igpu.py │ ├── api_oga_igpu_streaming.py │ ├── api_oga_npu.py │ ├── api_oga_npu_streaming.py │ ├── api_streaming.py │ ├── demos │ │ ├── README.md │ │ ├── chat │ │ │ ├── chat_hybrid.py │ │ │ └── chat_start.py │ │ └── search │ │ │ ├── search_hybrid.py │ │ │ └── search_start.py │ ├── notebooks │ │ └── lemonade_model_validation.ipynb │ └── server │ │ ├── README.md │ │ ├── ai-toolkit.md │ │ ├── anythingLLM.md │ │ ├── codeGPT.md │ │ ├── continue.md │ │ ├── lm-eval.md │ │ ├── mindcraft.md │ │ └── wut.md ├── readme.md └── turnkey │ ├── README.md │ ├── api │ ├── loading_a_build.py │ ├── onnx_opset.py │ └── scripts │ │ └── hello_world.py │ └── cli │ ├── onnx │ ├── README.md │ └── hello_world.onnx │ ├── plugins │ ├── example_tool │ │ ├── setup.py │ │ └── turnkeyml_plugin_example_tool │ │ │ ├── __init__.py │ │ │ └── tool.py │ └── readme.md │ ├── readme.md │ └── scripts │ ├── README.md │ ├── hello_world.py │ ├── max_depth.py │ ├── multiple_invocations.py │ └── two_models.py ├── img ├── basic_demo.gif ├── classic_demo.png ├── favicon.ico └── llm_demo.png ├── installer ├── AMD_LICENSE ├── Installer.nsi ├── add_to_path.py └── lemonade-server.bat ├── models ├── __init__.py ├── graph_convolutions │ ├── __init__.py │ ├── chebconv.py │ ├── dnaconv.py │ ├── feastconv.py │ ├── gatedgraphconv.py │ ├── generalconv.py │ ├── leconv.py │ ├── pnaconv.py │ ├── resgatedgraphconv.py │ ├── sageconv.py │ ├── skip │ │ ├── appnp.py │ │ ├── armaconv.py │ │ ├── cgconv.py │ │ ├── chebconv.py │ │ ├── dnaconv.py │ │ ├── egconv.py │ │ ├── feastconv.py │ │ ├── filmconv.py │ │ ├── gatedgraphconv.py │ │ ├── generalconv.py │ │ ├── ginconv.py │ │ ├── gineconv.py │ │ ├── gmmconv.py │ │ ├── leconv.py │ │ ├── lgconv.py │ │ ├── mfconv.py │ │ ├── nnconv.py │ │ ├── pnaconv.py │ │ ├── resgatedgraphconv.py │ │ ├── sageconv.py │ │ ├── signedconv.py │ │ └── tagconv.py │ └── tagconv.py ├── log.yml ├── readme.md ├── requirements.txt ├── selftest │ ├── __init__.py │ ├── linear.py │ └── twolayer.py ├── timm │ ├── __init__.py │ ├── adv_inception_v3.py │ ├── bat_resnext26ts.py │ ├── beit_base_patch16_224.py │ ├── beit_base_patch16_384.py │ ├── beit_large_patch16_224.py │ ├── beit_large_patch16_384.py │ ├── beit_large_patch16_512.py │ ├── botnet26t_256.py │ ├── botnet50ts_256.py │ ├── cait_m36_384.py │ ├── cait_m48_448.py │ ├── cait_s24_224.py │ ├── cait_s24_384.py │ ├── cait_s36_384.py │ ├── cait_xs24_384.py │ ├── cait_xxs24_224.py │ ├── cait_xxs24_384.py │ ├── cait_xxs36_224.py │ ├── cait_xxs36_384.py │ ├── coat_lite_mini.py │ ├── coat_lite_small.py │ ├── coat_lite_tiny.py │ ├── coat_mini.py │ ├── coat_tiny.py │ ├── convit_base.py │ ├── convit_small.py │ ├── convit_tiny.py │ ├── convmixer_1024_20_ks9_p14.py │ ├── convmixer_1536_20.py │ ├── convmixer_768_32.py │ ├── convnext_base.py │ ├── convnext_base_384_in22ft1k.py │ ├── convnext_base_in22ft1k.py │ ├── convnext_base_in22k.py │ ├── convnext_large.py │ ├── convnext_large_384_in22ft1k.py │ ├── convnext_large_in22ft1k.py │ ├── convnext_large_in22k.py │ ├── convnext_nano.py │ ├── convnext_nano_ols.py │ ├── convnext_small.py │ ├── convnext_small_384_in22ft1k.py │ ├── convnext_small_in22ft1k.py │ ├── convnext_small_in22k.py │ ├── convnext_tiny.py │ ├── convnext_tiny_384_in22ft1k.py │ ├── convnext_tiny_hnf.py │ ├── convnext_tiny_in22ft1k.py │ ├── convnext_tiny_in22k.py │ ├── convnext_xlarge_384_in22ft1k.py │ ├── convnext_xlarge_in22ft1k.py │ ├── convnext_xlarge_in22k.py │ ├── crossvit_15_240.py │ ├── crossvit_15_dagger_240.py │ ├── crossvit_15_dagger_408.py │ ├── crossvit_18_240.py │ ├── crossvit_18_dagger_240.py │ ├── crossvit_18_dagger_408.py │ ├── crossvit_9_240.py │ ├── crossvit_9_dagger_240.py │ ├── crossvit_base_240.py │ ├── crossvit_small_240.py │ ├── crossvit_tiny_240.py │ ├── cs3darknet_focus_l.py │ ├── cs3darknet_focus_m.py │ ├── cs3darknet_focus_s.py │ ├── cs3darknet_focus_x.py │ ├── cs3darknet_l.py │ ├── cs3darknet_m.py │ ├── cs3darknet_s.py │ ├── cs3darknet_x.py │ ├── cs3edgenet_x.py │ ├── cs3se_edgenet_x.py │ ├── cs3sedarknet_l.py │ ├── cs3sedarknet_x.py │ ├── cs3sedarknet_xdw.py │ ├── cspdarknet53.py │ ├── cspresnet50.py │ ├── cspresnet50d.py │ ├── cspresnet50w.py │ ├── cspresnext50.py │ ├── darknet17.py │ ├── darknet21.py │ ├── darknet53.py │ ├── darknetaa53.py │ ├── deit3_base_patch16_224.py │ ├── deit3_base_patch16_224_in21ft1k.py │ ├── deit3_base_patch16_384.py │ ├── deit3_base_patch16_384_in21ft1k.py │ ├── deit3_huge_patch14_224.py │ ├── deit3_huge_patch14_224_in21ft1k.py │ ├── deit3_large_patch16_224.py │ ├── deit3_large_patch16_224_in21ft1k.py │ ├── deit3_large_patch16_384.py │ ├── deit3_large_patch16_384_in21ft1k.py │ ├── deit3_small_patch16_224.py │ ├── deit3_small_patch16_224_in21ft1k.py │ ├── deit3_small_patch16_384.py │ ├── deit3_small_patch16_384_in21ft1k.py │ ├── deit_base_distilled_patch16_224.py │ ├── deit_base_distilled_patch16_384.py │ ├── deit_base_patch16_224.py │ ├── deit_base_patch16_384.py │ ├── deit_small_distilled_patch16_224.py │ ├── deit_small_patch16_224.py │ ├── deit_tiny_distilled_patch16_224.py │ ├── deit_tiny_patch16_224.py │ ├── densenet121.py │ ├── densenet161.py │ ├── densenet169.py │ ├── densenet201.py │ ├── densenetblur121d.py │ ├── dla102.py │ ├── dla102x.py │ ├── dla102x2.py │ ├── dla169.py │ ├── dla34.py │ ├── dla46_c.py │ ├── dla46x_c.py │ ├── dla60.py │ ├── dla60_res2net.py │ ├── dla60_res2next.py │ ├── dla60x.py │ ├── dla60x_c.py │ ├── dm_nfnet_f0.py │ ├── dm_nfnet_f1.py │ ├── dm_nfnet_f2.py │ ├── dm_nfnet_f3.py │ ├── dm_nfnet_f4.py │ ├── dm_nfnet_f5.py │ ├── dm_nfnet_f6.py │ ├── dpn107.py │ ├── dpn131.py │ ├── dpn68.py │ ├── dpn68b.py │ ├── dpn92.py │ ├── dpn98.py │ ├── eca_botnext26ts_256.py │ ├── eca_halonext26ts.py │ ├── eca_nfnet_l0.py │ ├── eca_nfnet_l1.py │ ├── eca_nfnet_l2.py │ ├── eca_nfnet_l3.py │ ├── eca_resnet33ts.py │ ├── eca_resnext26ts.py │ ├── eca_vovnet39b.py │ ├── ecaresnet101d.py │ ├── ecaresnet200d.py │ ├── ecaresnet269d.py │ ├── ecaresnet26t.py │ ├── ecaresnet50d.py │ ├── ecaresnet50t.py │ ├── ecaresnetlight.py │ ├── ecaresnext26t_32x4d.py │ ├── ecaresnext50t_32x4d.py │ ├── edgenext_small.py │ ├── edgenext_small_rw.py │ ├── edgenext_x_small.py │ ├── edgenext_xx_small.py │ ├── efficientnet_b0.py │ ├── efficientnet_b0_g16_evos.py │ ├── efficientnet_b0_g8_gn.py │ ├── efficientnet_b0_gn.py │ ├── efficientnet_b1.py │ ├── efficientnet_b2.py │ ├── efficientnet_b2a.py │ ├── efficientnet_b3.py │ ├── efficientnet_b3_g8_gn.py │ ├── efficientnet_b3_gn.py │ ├── efficientnet_b3a.py │ ├── efficientnet_b4.py │ ├── efficientnet_b5.py │ ├── efficientnet_b6.py │ ├── efficientnet_b7.py │ ├── efficientnet_b8.py │ ├── efficientnet_cc_b0_4e.py │ ├── efficientnet_cc_b0_8e.py │ ├── efficientnet_cc_b1_8e.py │ ├── efficientnet_el.py │ ├── efficientnet_el_pruned.py │ ├── efficientnet_em.py │ ├── efficientnet_es.py │ ├── efficientnet_es_pruned.py │ ├── efficientnet_l2.py │ ├── efficientnet_lite0.py │ ├── efficientnet_lite1.py │ ├── efficientnet_lite2.py │ ├── efficientnet_lite3.py │ ├── efficientnet_lite4.py │ ├── efficientnetv2_l.py │ ├── efficientnetv2_m.py │ ├── efficientnetv2_rw_m.py │ ├── efficientnetv2_rw_s.py │ ├── efficientnetv2_rw_t.py │ ├── efficientnetv2_s.py │ ├── efficientnetv2_xl.py │ ├── ens_adv_inception_resnet_v2.py │ ├── ese_vovnet19b_dw.py │ ├── ese_vovnet19b_slim.py │ ├── ese_vovnet19b_slim_dw.py │ ├── ese_vovnet39b.py │ ├── ese_vovnet39b_evos.py │ ├── ese_vovnet57b.py │ ├── ese_vovnet99b.py │ ├── fbnetc_100.py │ ├── fbnetv3_b.py │ ├── fbnetv3_d.py │ ├── fbnetv3_g.py │ ├── gc_efficientnetv2_rw_t.py │ ├── gcresnet33ts.py │ ├── gcresnet50t.py │ ├── gcresnext26ts.py │ ├── gcresnext50ts.py │ ├── gernet_l.py │ ├── gernet_m.py │ ├── gernet_s.py │ ├── ghostnet_050.py │ ├── ghostnet_100.py │ ├── ghostnet_130.py │ ├── gluon_inception_v3.py │ ├── gluon_resnet101_v1b.py │ ├── gluon_resnet101_v1c.py │ ├── gluon_resnet101_v1d.py │ ├── gluon_resnet101_v1s.py │ ├── gluon_resnet152_v1b.py │ ├── gluon_resnet152_v1c.py │ ├── gluon_resnet152_v1d.py │ ├── gluon_resnet152_v1s.py │ ├── gluon_resnet18_v1b.py │ ├── gluon_resnet34_v1b.py │ ├── gluon_resnet50_v1b.py │ ├── gluon_resnet50_v1c.py │ ├── gluon_resnet50_v1d.py │ ├── gluon_resnet50_v1s.py │ ├── gluon_resnext101_32x4d.py │ ├── gluon_resnext101_64x4d.py │ ├── gluon_resnext50_32x4d.py │ ├── gluon_senet154.py │ ├── gluon_seresnext101_32x4d.py │ ├── gluon_seresnext101_64x4d.py │ ├── gluon_seresnext50_32x4d.py │ ├── gmixer_12_224.py │ ├── gmixer_24_224.py │ ├── gmlp_b16_224.py │ ├── gmlp_s16_224.py │ ├── gmlp_ti16_224.py │ ├── halo2botnet50ts_256.py │ ├── halonet26t.py │ ├── halonet50ts.py │ ├── halonet_h1.py │ ├── haloregnetz_b.py │ ├── hardcorenas_a.py │ ├── hardcorenas_b.py │ ├── hardcorenas_c.py │ ├── hardcorenas_d.py │ ├── hardcorenas_e.py │ ├── hardcorenas_f.py │ ├── hrnet_w18.py │ ├── hrnet_w18_small.py │ ├── hrnet_w18_small_v2.py │ ├── hrnet_w30.py │ ├── hrnet_w32.py │ ├── hrnet_w40.py │ ├── hrnet_w44.py │ ├── hrnet_w48.py │ ├── hrnet_w64.py │ ├── ig_resnext101_32x16d.py │ ├── ig_resnext101_32x32d.py │ ├── ig_resnext101_32x48d.py │ ├── ig_resnext101_32x8d.py │ ├── inception_resnet_v2.py │ ├── inception_v3.py │ ├── inception_v4.py │ ├── jx_nest_base.py │ ├── jx_nest_small.py │ ├── jx_nest_tiny.py │ ├── lambda_resnet26rpt_256.py │ ├── lambda_resnet26t.py │ ├── lambda_resnet50ts.py │ ├── lamhalobotnet50ts_256.py │ ├── lcnet_035.py │ ├── lcnet_050.py │ ├── lcnet_075.py │ ├── lcnet_100.py │ ├── lcnet_150.py │ ├── legacy_senet154.py │ ├── legacy_seresnet101.py │ ├── legacy_seresnet152.py │ ├── legacy_seresnet18.py │ ├── legacy_seresnet34.py │ ├── legacy_seresnet50.py │ ├── legacy_seresnext101_32x4d.py │ ├── legacy_seresnext26_32x4d.py │ ├── legacy_seresnext50_32x4d.py │ ├── levit_128.py │ ├── levit_128s.py │ ├── levit_192.py │ ├── levit_256.py │ ├── levit_256d.py │ ├── levit_384.py │ ├── mixer_b16_224.py │ ├── mixer_b16_224_in21k.py │ ├── mixer_b16_224_miil.py │ ├── mixer_b16_224_miil_in21k.py │ ├── mixer_b32_224.py │ ├── mixer_l16_224.py │ ├── mixer_l16_224_in21k.py │ ├── mixer_l32_224.py │ ├── mixer_s16_224.py │ ├── mixer_s32_224.py │ ├── mixnet_l.py │ ├── mixnet_m.py │ ├── mixnet_s.py │ ├── mixnet_xl.py │ ├── mixnet_xxl.py │ ├── mnasnet_050.py │ ├── mnasnet_075.py │ ├── mnasnet_100.py │ ├── mnasnet_140.py │ ├── mnasnet_a1.py │ ├── mnasnet_b1.py │ ├── mnasnet_small.py │ ├── mobilenetv2_035.py │ ├── mobilenetv2_050.py │ ├── mobilenetv2_075.py │ ├── mobilenetv2_100.py │ ├── mobilenetv2_110d.py │ ├── mobilenetv2_120d.py │ ├── mobilenetv2_140.py │ ├── mobilenetv3_large_075.py │ ├── mobilenetv3_large_100.py │ ├── mobilenetv3_large_100_miil.py │ ├── mobilenetv3_large_100_miil_in21k.py │ ├── mobilenetv3_rw.py │ ├── mobilenetv3_small_050.py │ ├── mobilenetv3_small_075.py │ ├── mobilenetv3_small_100.py │ ├── mobilevit_s.py │ ├── mobilevit_xs.py │ ├── mobilevit_xxs.py │ ├── mobilevitv2_050.py │ ├── mobilevitv2_075.py │ ├── mobilevitv2_100.py │ ├── mobilevitv2_125.py │ ├── mobilevitv2_150.py │ ├── mobilevitv2_150_384_in22ft1k.py │ ├── mobilevitv2_150_in22ft1k.py │ ├── mobilevitv2_175.py │ ├── mobilevitv2_175_384_in22ft1k.py │ ├── mobilevitv2_175_in22ft1k.py │ ├── mobilevitv2_200.py │ ├── mobilevitv2_200_384_in22ft1k.py │ ├── mobilevitv2_200_in22ft1k.py │ ├── nasnetalarge.py │ ├── nest_base.py │ ├── nest_small.py │ ├── nest_tiny.py │ ├── nf_ecaresnet101.py │ ├── nf_ecaresnet26.py │ ├── nf_ecaresnet50.py │ ├── nf_regnet_b0.py │ ├── nf_regnet_b1.py │ ├── nf_regnet_b2.py │ ├── nf_regnet_b3.py │ ├── nf_regnet_b4.py │ ├── nf_regnet_b5.py │ ├── nf_resnet101.py │ ├── nf_resnet26.py │ ├── nf_resnet50.py │ ├── nf_seresnet101.py │ ├── nf_seresnet26.py │ ├── nf_seresnet50.py │ ├── nfnet_f0.py │ ├── nfnet_f1.py │ ├── nfnet_f2.py │ ├── nfnet_f3.py │ ├── nfnet_f4.py │ ├── nfnet_f5.py │ ├── nfnet_f6.py │ ├── nfnet_f7.py │ ├── nfnet_l0.py │ ├── pit_b_224.py │ ├── pit_b_distilled_224.py │ ├── pit_s_224.py │ ├── pit_s_distilled_224.py │ ├── pit_ti_224.py │ ├── pit_ti_distilled_224.py │ ├── pit_xs_224.py │ ├── pit_xs_distilled_224.py │ ├── pnasnet5large.py │ ├── poolformer_m36.py │ ├── poolformer_m48.py │ ├── poolformer_s12.py │ ├── poolformer_s24.py │ ├── poolformer_s36.py │ ├── regnetv_040.py │ ├── regnetv_064.py │ ├── regnetx_002.py │ ├── regnetx_004.py │ ├── regnetx_006.py │ ├── regnetx_008.py │ ├── regnetx_016.py │ ├── regnetx_032.py │ ├── regnetx_040.py │ ├── regnetx_064.py │ ├── regnetx_080.py │ ├── regnetx_120.py │ ├── regnetx_160.py │ ├── regnetx_320.py │ ├── regnety_002.py │ ├── regnety_004.py │ ├── regnety_006.py │ ├── regnety_008.py │ ├── regnety_016.py │ ├── regnety_032.py │ ├── regnety_040.py │ ├── regnety_064.py │ ├── regnety_080.py │ ├── regnety_120.py │ ├── regnety_160.py │ ├── regnety_320.py │ ├── regnetz_005.py │ ├── regnetz_040.py │ ├── regnetz_040h.py │ ├── regnetz_b16.py │ ├── regnetz_b16_evos.py │ ├── regnetz_c16.py │ ├── regnetz_c16_evos.py │ ├── regnetz_d32.py │ ├── regnetz_d8.py │ ├── regnetz_d8_evos.py │ ├── regnetz_e8.py │ ├── repvgg_a2.py │ ├── repvgg_b0.py │ ├── repvgg_b1.py │ ├── repvgg_b1g4.py │ ├── repvgg_b2.py │ ├── repvgg_b2g4.py │ ├── repvgg_b3.py │ ├── repvgg_b3g4.py │ ├── res2net101_26w_4s.py │ ├── res2net50_14w_8s.py │ ├── res2net50_26w_4s.py │ ├── res2net50_26w_6s.py │ ├── res2net50_26w_8s.py │ ├── res2net50_48w_2s.py │ ├── res2next50.py │ ├── resmlp_12_224.py │ ├── resmlp_12_224_dino.py │ ├── resmlp_12_distilled_224.py │ ├── resmlp_24_224.py │ ├── resmlp_24_224_dino.py │ ├── resmlp_24_distilled_224.py │ ├── resmlp_36_224.py │ ├── resmlp_36_distilled_224.py │ ├── resmlp_big_24_224.py │ ├── resmlp_big_24_224_in22ft1k.py │ ├── resmlp_big_24_distilled_224.py │ ├── resnest101e.py │ ├── resnest14d.py │ ├── resnest200e.py │ ├── resnest269e.py │ ├── resnest26d.py │ ├── resnest50d.py │ ├── resnest50d_1s4x24d.py │ ├── resnest50d_4s2x40d.py │ ├── resnet101.py │ ├── resnet101d.py │ ├── resnet10t.py │ ├── resnet14t.py │ ├── resnet152.py │ ├── resnet152d.py │ ├── resnet18.py │ ├── resnet18d.py │ ├── resnet200.py │ ├── resnet200d.py │ ├── resnet26.py │ ├── resnet26d.py │ ├── resnet26t.py │ ├── resnet32ts.py │ ├── resnet33ts.py │ ├── resnet34.py │ ├── resnet34d.py │ ├── resnet50.py │ ├── resnet50_gn.py │ ├── resnet50d.py │ ├── resnet50t.py │ ├── resnet51q.py │ ├── resnet61q.py │ ├── resnetaa101d.py │ ├── resnetaa50.py │ ├── resnetaa50d.py │ ├── resnetblur101d.py │ ├── resnetblur18.py │ ├── resnetblur50.py │ ├── resnetblur50d.py │ ├── resnetrs101.py │ ├── resnetrs152.py │ ├── resnetrs200.py │ ├── resnetrs270.py │ ├── resnetrs350.py │ ├── resnetrs420.py │ ├── resnetrs50.py │ ├── resnetv2_101.py │ ├── resnetv2_101d.py │ ├── resnetv2_101x1_bitm.py │ ├── resnetv2_101x1_bitm_in21k.py │ ├── resnetv2_101x3_bitm.py │ ├── resnetv2_101x3_bitm_in21k.py │ ├── resnetv2_152.py │ ├── resnetv2_152d.py │ ├── resnetv2_152x2_bit_teacher.py │ ├── resnetv2_152x2_bit_teacher_384.py │ ├── resnetv2_152x2_bitm.py │ ├── resnetv2_152x2_bitm_in21k.py │ ├── resnetv2_152x4_bitm.py │ ├── resnetv2_152x4_bitm_in21k.py │ ├── resnetv2_50.py │ ├── resnetv2_50d.py │ ├── resnetv2_50d_evos.py │ ├── resnetv2_50d_frn.py │ ├── resnetv2_50d_gn.py │ ├── resnetv2_50t.py │ ├── resnetv2_50x1_bit_distilled.py │ ├── resnetv2_50x1_bitm.py │ ├── resnetv2_50x1_bitm_in21k.py │ ├── resnetv2_50x3_bitm.py │ ├── resnetv2_50x3_bitm_in21k.py │ ├── resnext101_32x4d.py │ ├── resnext101_32x8d.py │ ├── resnext101_64x4d.py │ ├── resnext26ts.py │ ├── resnext50_32x4d.py │ ├── resnext50d_32x4d.py │ ├── rexnet_100.py │ ├── rexnet_130.py │ ├── rexnet_150.py │ ├── rexnet_200.py │ ├── rexnetr_100.py │ ├── rexnetr_130.py │ ├── rexnetr_150.py │ ├── rexnetr_200.py │ ├── sebotnet33ts_256.py │ ├── sedarknet21.py │ ├── sehalonet33ts.py │ ├── selecsls42.py │ ├── selecsls42b.py │ ├── selecsls60.py │ ├── selecsls60b.py │ ├── selecsls84.py │ ├── semnasnet_050.py │ ├── semnasnet_075.py │ ├── semnasnet_100.py │ ├── semnasnet_140.py │ ├── senet154.py │ ├── sequencer2d_l.py │ ├── sequencer2d_m.py │ ├── sequencer2d_s.py │ ├── seresnet101.py │ ├── seresnet152.py │ ├── seresnet152d.py │ ├── seresnet18.py │ ├── seresnet200d.py │ ├── seresnet269d.py │ ├── seresnet33ts.py │ ├── seresnet34.py │ ├── seresnet50.py │ ├── seresnet50t.py │ ├── seresnetaa50d.py │ ├── seresnext101_32x4d.py │ ├── seresnext101_32x8d.py │ ├── seresnext101d_32x8d.py │ ├── seresnext26d_32x4d.py │ ├── seresnext26t_32x4d.py │ ├── seresnext26tn_32x4d.py │ ├── seresnext26ts.py │ ├── seresnext50_32x4d.py │ ├── seresnextaa101d_32x8d.py │ ├── skip │ │ ├── beit_base_patch16_224_in22k.py │ │ ├── beit_large_patch16_224_in22k.py │ │ ├── convnext_nano_hnf.py │ │ ├── densenet121d.py │ │ ├── densenet264.py │ │ ├── densenet264d_iabn.py │ │ ├── ecaresnet101d_pruned.py │ │ ├── ecaresnet50d_pruned.py │ │ ├── efficientnet_b1_pruned.py │ │ ├── efficientnet_b2_pruned.py │ │ ├── efficientnet_b3_pruned.py │ │ ├── ese_vovnet99b_iabn.py │ │ ├── gluon_xception65.py │ │ ├── regnety_040s_gn.py │ │ ├── resnetv2_50d_evob.py │ │ ├── semobilevit_s.py │ │ ├── tresnet_l.py │ │ ├── tresnet_l_448.py │ │ ├── tresnet_m.py │ │ ├── tresnet_m_448.py │ │ ├── tresnet_m_miil_in21k.py │ │ ├── tresnet_xl.py │ │ ├── tresnet_xl_448.py │ │ ├── tv_densenet121.py │ │ ├── vit_base_patch16_224_sam.py │ │ ├── vit_base_patch32_224_sam.py │ │ ├── vit_base_r26_s32_224.py │ │ ├── vit_base_r50_s16_224.py │ │ ├── vit_base_r50_s16_224_in21k.py │ │ ├── vit_base_r50_s16_384.py │ │ ├── vit_base_resnet26d_224.py │ │ ├── vit_base_resnet50_224_in21k.py │ │ ├── vit_base_resnet50_384.py │ │ ├── vit_base_resnet50d_224.py │ │ ├── vit_large_r50_s32_224.py │ │ ├── vit_large_r50_s32_224_in21k.py │ │ ├── vit_large_r50_s32_384.py │ │ ├── vit_small_r26_s32_224.py │ │ ├── vit_small_r26_s32_224_in21k.py │ │ ├── vit_small_r26_s32_384.py │ │ ├── vit_small_resnet26d_224.py │ │ ├── vit_small_resnet50d_s16_224.py │ │ ├── vit_tiny_r_s16_p8_224.py │ │ ├── vit_tiny_r_s16_p8_224_in21k.py │ │ ├── vit_tiny_r_s16_p8_384.py │ │ └── xcit_small_24_p16_384_dist.py │ ├── skresnet18.py │ ├── skresnet34.py │ ├── skresnet50.py │ ├── skresnet50d.py │ ├── skresnext50_32x4d.py │ ├── spnasnet_100.py │ ├── ssl_resnet18.py │ ├── ssl_resnet50.py │ ├── ssl_resnext101_32x16d.py │ ├── ssl_resnext101_32x4d.py │ ├── ssl_resnext101_32x8d.py │ ├── ssl_resnext50_32x4d.py │ ├── swin_base_patch4_window12_384.py │ ├── swin_base_patch4_window12_384_in22k.py │ ├── swin_base_patch4_window7_224.py │ ├── swin_base_patch4_window7_224_in22k.py │ ├── swin_large_patch4_window12_384.py │ ├── swin_large_patch4_window12_384_in22k.py │ ├── swin_large_patch4_window7_224.py │ ├── swin_large_patch4_window7_224_in22k.py │ ├── swin_s3_base_224.py │ ├── swin_s3_small_224.py │ ├── swin_s3_tiny_224.py │ ├── swin_small_patch4_window7_224.py │ ├── swin_tiny_patch4_window7_224.py │ ├── swinv2_base_window12_192_22k.py │ ├── swinv2_base_window12to16_192to256_22kft1k.py │ ├── swinv2_base_window12to24_192to384_22kft1k.py │ ├── swinv2_base_window16_256.py │ ├── swinv2_base_window8_256.py │ ├── swinv2_cr_base_224.py │ ├── swinv2_cr_base_384.py │ ├── swinv2_cr_base_ns_224.py │ ├── swinv2_cr_giant_224.py │ ├── swinv2_cr_giant_384.py │ ├── swinv2_cr_huge_224.py │ ├── swinv2_cr_huge_384.py │ ├── swinv2_cr_large_224.py │ ├── swinv2_cr_large_384.py │ ├── swinv2_cr_small_224.py │ ├── swinv2_cr_small_384.py │ ├── swinv2_cr_small_ns_224.py │ ├── swinv2_cr_tiny_224.py │ ├── swinv2_cr_tiny_384.py │ ├── swinv2_cr_tiny_ns_224.py │ ├── swinv2_large_window12_192_22k.py │ ├── swinv2_large_window12to16_192to256_22kft1k.py │ ├── swinv2_large_window12to24_192to384_22kft1k.py │ ├── swinv2_small_window16_256.py │ ├── swinv2_small_window8_256.py │ ├── swinv2_tiny_window16_256.py │ ├── swinv2_tiny_window8_256.py │ ├── swsl_resnet18.py │ ├── swsl_resnet50.py │ ├── swsl_resnext101_32x16d.py │ ├── swsl_resnext101_32x4d.py │ ├── swsl_resnext101_32x8d.py │ ├── swsl_resnext50_32x4d.py │ ├── tf_efficientnet_b0.py │ ├── tf_efficientnet_b0_ap.py │ ├── tf_efficientnet_b0_ns.py │ ├── tf_efficientnet_b1.py │ ├── tf_efficientnet_b1_ap.py │ ├── tf_efficientnet_b1_ns.py │ ├── tf_efficientnet_b2.py │ ├── tf_efficientnet_b2_ap.py │ ├── tf_efficientnet_b2_ns.py │ ├── tf_efficientnet_b3.py │ ├── tf_efficientnet_b3_ap.py │ ├── tf_efficientnet_b3_ns.py │ ├── tf_efficientnet_b4.py │ ├── tf_efficientnet_b4_ap.py │ ├── tf_efficientnet_b4_ns.py │ ├── tf_efficientnet_b5.py │ ├── tf_efficientnet_b5_ap.py │ ├── tf_efficientnet_b5_ns.py │ ├── tf_efficientnet_b6.py │ ├── tf_efficientnet_b6_ap.py │ ├── tf_efficientnet_b6_ns.py │ ├── tf_efficientnet_b7.py │ ├── tf_efficientnet_b7_ap.py │ ├── tf_efficientnet_b7_ns.py │ ├── tf_efficientnet_b8.py │ ├── tf_efficientnet_b8_ap.py │ ├── tf_efficientnet_cc_b0_4e.py │ ├── tf_efficientnet_cc_b0_8e.py │ ├── tf_efficientnet_cc_b1_8e.py │ ├── tf_efficientnet_el.py │ ├── tf_efficientnet_em.py │ ├── tf_efficientnet_es.py │ ├── tf_efficientnet_l2_ns.py │ ├── tf_efficientnet_l2_ns_475.py │ ├── tf_efficientnet_lite0.py │ ├── tf_efficientnet_lite1.py │ ├── tf_efficientnet_lite2.py │ ├── tf_efficientnet_lite3.py │ ├── tf_efficientnet_lite4.py │ ├── tf_efficientnetv2_b0.py │ ├── tf_efficientnetv2_b1.py │ ├── tf_efficientnetv2_b2.py │ ├── tf_efficientnetv2_b3.py │ ├── tf_efficientnetv2_l.py │ ├── tf_efficientnetv2_l_in21ft1k.py │ ├── tf_efficientnetv2_l_in21k.py │ ├── tf_efficientnetv2_m.py │ ├── tf_efficientnetv2_m_in21ft1k.py │ ├── tf_efficientnetv2_m_in21k.py │ ├── tf_efficientnetv2_s.py │ ├── tf_efficientnetv2_s_in21ft1k.py │ ├── tf_efficientnetv2_s_in21k.py │ ├── tf_efficientnetv2_xl_in21ft1k.py │ ├── tf_efficientnetv2_xl_in21k.py │ ├── tf_inception_v3.py │ ├── tf_mixnet_l.py │ ├── tf_mixnet_m.py │ ├── tf_mixnet_s.py │ ├── tf_mobilenetv3_large_075.py │ ├── tf_mobilenetv3_large_100.py │ ├── tf_mobilenetv3_large_minimal_100.py │ ├── tf_mobilenetv3_small_075.py │ ├── tf_mobilenetv3_small_100.py │ ├── tf_mobilenetv3_small_minimal_100.py │ ├── tinynet_a.py │ ├── tinynet_b.py │ ├── tinynet_c.py │ ├── tinynet_d.py │ ├── tinynet_e.py │ ├── tnt_b_patch16_224.py │ ├── tnt_s_patch16_224.py │ ├── tv_resnet101.py │ ├── tv_resnet152.py │ ├── tv_resnet34.py │ ├── tv_resnet50.py │ ├── tv_resnext50_32x4d.py │ ├── twins_pcpvt_base.py │ ├── twins_pcpvt_large.py │ ├── twins_pcpvt_small.py │ ├── twins_svt_base.py │ ├── twins_svt_large.py │ ├── twins_svt_small.py │ ├── vgg11.py │ ├── vgg11_bn.py │ ├── vgg13.py │ ├── vgg13_bn.py │ ├── vgg16.py │ ├── vgg16_bn.py │ ├── vgg19.py │ ├── vgg19_bn.py │ ├── visformer_small.py │ ├── visformer_tiny.py │ ├── vit_base_patch16_18x2_224.py │ ├── vit_base_patch16_224.py │ ├── vit_base_patch16_224_dino.py │ ├── vit_base_patch16_224_in21k.py │ ├── vit_base_patch16_224_miil.py │ ├── vit_base_patch16_224_miil_in21k.py │ ├── vit_base_patch16_384.py │ ├── vit_base_patch16_plus_240.py │ ├── vit_base_patch16_rpn_224.py │ ├── vit_base_patch32_224.py │ ├── vit_base_patch32_224_in21k.py │ ├── vit_base_patch32_384.py │ ├── vit_base_patch32_plus_256.py │ ├── vit_base_patch8_224.py │ ├── vit_base_patch8_224_dino.py │ ├── vit_base_patch8_224_in21k.py │ ├── vit_giant_patch14_224.py │ ├── vit_gigantic_patch14_224.py │ ├── vit_huge_patch14_224.py │ ├── vit_huge_patch14_224_in21k.py │ ├── vit_large_patch14_224.py │ ├── vit_large_patch16_224.py │ ├── vit_large_patch16_224_in21k.py │ ├── vit_large_patch16_384.py │ ├── vit_large_patch32_224.py │ ├── vit_large_patch32_224_in21k.py │ ├── vit_large_patch32_384.py │ ├── vit_relpos_base_patch16_224.py │ ├── vit_relpos_base_patch16_cls_224.py │ ├── vit_relpos_base_patch16_clsgap_224.py │ ├── vit_relpos_base_patch16_plus_240.py │ ├── vit_relpos_base_patch16_rpn_224.py │ ├── vit_relpos_base_patch32_plus_rpn_256.py │ ├── vit_relpos_medium_patch16_224.py │ ├── vit_relpos_medium_patch16_cls_224.py │ ├── vit_relpos_medium_patch16_rpn_224.py │ ├── vit_relpos_small_patch16_224.py │ ├── vit_relpos_small_patch16_rpn_224.py │ ├── vit_small_patch16_18x2_224.py │ ├── vit_small_patch16_224.py │ ├── vit_small_patch16_224_dino.py │ ├── vit_small_patch16_224_in21k.py │ ├── vit_small_patch16_36x1_224.py │ ├── vit_small_patch16_384.py │ ├── vit_small_patch32_224.py │ ├── vit_small_patch32_224_in21k.py │ ├── vit_small_patch32_384.py │ ├── vit_small_patch8_224_dino.py │ ├── vit_srelpos_medium_patch16_224.py │ ├── vit_srelpos_small_patch16_224.py │ ├── vit_tiny_patch16_224.py │ ├── vit_tiny_patch16_224_in21k.py │ ├── vit_tiny_patch16_384.py │ ├── volo_d1_224.py │ ├── volo_d1_384.py │ ├── volo_d2_224.py │ ├── volo_d2_384.py │ ├── volo_d3_224.py │ ├── volo_d3_448.py │ ├── volo_d4_224.py │ ├── volo_d4_448.py │ ├── volo_d5_224.py │ ├── volo_d5_448.py │ ├── volo_d5_512.py │ ├── vovnet39a.py │ ├── vovnet57a.py │ ├── wide_resnet101_2.py │ ├── wide_resnet50_2.py │ ├── xception.py │ ├── xception41.py │ ├── xception41p.py │ ├── xception65.py │ ├── xception65p.py │ ├── xception71.py │ ├── xcit_large_24_p16_224.py │ ├── xcit_large_24_p16_224_dist.py │ ├── xcit_large_24_p16_384_dist.py │ ├── xcit_large_24_p8_224.py │ ├── xcit_large_24_p8_224_dist.py │ ├── xcit_large_24_p8_384_dist.py │ ├── xcit_medium_24_p16_224.py │ ├── xcit_medium_24_p16_224_dist.py │ ├── xcit_medium_24_p16_384_dist.py │ ├── xcit_medium_24_p8_224.py │ ├── xcit_medium_24_p8_224_dist.py │ ├── xcit_medium_24_p8_384_dist.py │ ├── xcit_nano_12_p16_224.py │ ├── xcit_nano_12_p16_224_dist.py │ ├── xcit_nano_12_p16_384_dist.py │ ├── xcit_nano_12_p8_224.py │ ├── xcit_nano_12_p8_224_dist.py │ ├── xcit_nano_12_p8_384_dist.py │ ├── xcit_small_12_p16_224.py │ ├── xcit_small_12_p16_224_dist.py │ ├── xcit_small_12_p16_384_dist.py │ ├── xcit_small_12_p8_224.py │ ├── xcit_small_12_p8_224_dist.py │ ├── xcit_small_12_p8_384_dist.py │ ├── xcit_small_24_p16_224.py │ ├── xcit_small_24_p16_224_dist.py │ ├── xcit_small_24_p8_224.py │ ├── xcit_small_24_p8_224_dist.py │ ├── xcit_small_24_p8_384_dist.py │ ├── xcit_tiny_12_p16_224.py │ ├── xcit_tiny_12_p16_224_dist.py │ ├── xcit_tiny_12_p16_384_dist.py │ ├── xcit_tiny_12_p8_224.py │ ├── xcit_tiny_12_p8_224_dist.py │ ├── xcit_tiny_12_p8_384_dist.py │ ├── xcit_tiny_24_p16_224.py │ ├── xcit_tiny_24_p16_224_dist.py │ ├── xcit_tiny_24_p16_384_dist.py │ ├── xcit_tiny_24_p8_224.py │ ├── xcit_tiny_24_p8_224_dist.py │ └── xcit_tiny_24_p8_384_dist.py ├── torch_hub │ ├── __init__.py │ ├── alexnet.py │ ├── convnext_base.py │ ├── convnext_large.py │ ├── convnext_small.py │ ├── convnext_tiny.py │ ├── densenet121.py │ ├── densenet161.py │ ├── densenet169.py │ ├── densenet201.py │ ├── efficientnet_b1.py │ ├── efficientnet_v2_l.py │ ├── efficientnet_v2_m.py │ ├── efficientnet_v2_s.py │ ├── googlenet.py │ ├── hardnet39ds.py │ ├── hardnet68.py │ ├── hardnet68ds.py │ ├── hardnet85.py │ ├── inception_v3.py │ ├── mealv1_resnest50.py │ ├── mealv2_efficientnet_b0.py │ ├── mealv2_mobilenet_v3_large_100.py │ ├── mealv2_mobilenetv3_small_075.py │ ├── mealv2_mobilenetv3_small_100.py │ ├── mealv2_resnest50.py │ ├── mealv2_resnest50_380x380.py │ ├── mealv2_resnest50_cutmix.py │ ├── midas_v2.1_small.py │ ├── midas_v3_large.py │ ├── mnasnet0_5.py │ ├── mnasnet0_75.py │ ├── mnasnet1_0.py │ ├── mnasnet1_3.py │ ├── mobilenet_v2.py │ ├── mobilenet_v3_large.py │ ├── mobilenet_v3_small.py │ ├── proxyless_cpu.py │ ├── proxyless_gpu.py │ ├── proxyless_mobile.py │ ├── proxyless_mobile_14.py │ ├── regnet_x_16gf.py │ ├── regnet_x_1_6gf.py │ ├── regnet_x_32gf.py │ ├── regnet_x_3_2gf.py │ ├── regnet_x_400mf.py │ ├── regnet_x_800mf.py │ ├── regnet_x_8gf.py │ ├── regnet_y_128gf.py │ ├── regnet_y_16gf.py │ ├── regnet_y_1_6gf.py │ ├── regnet_y_32gf.py │ ├── regnet_y_3_2gf.py │ ├── regnet_y_400mf.py │ ├── regnet_y_800mf.py │ ├── regnet_y_8gf.py │ ├── resnest101.py │ ├── resnest200.py │ ├── resnest269.py │ ├── resnest50.py │ ├── resnest50_fast_1s1x64d.py │ ├── resnest50_fast_1s2x40d.py │ ├── resnest50_fast_1s4x24d.py │ ├── resnest50_fast_2s1x64d.py │ ├── resnest50_fast_2s2x40d.py │ ├── resnest50_fast_4s1x64d.py │ ├── resnest50_fast_4s2x40d.py │ ├── resnet101.py │ ├── resnet101_ibn_a.py │ ├── resnet101_ibn_b.py │ ├── resnet152.py │ ├── resnet18.py │ ├── resnet18_ibn_a.py │ ├── resnet18_ibn_b.py │ ├── resnet34.py │ ├── resnet34_ibn_a.py │ ├── resnet34_ibn_b.py │ ├── resnet50.py │ ├── resnet50_ibn_a.py │ ├── resnet50_ibn_b.py │ ├── resnext101_32x8d.py │ ├── resnext101_ibn_a.py │ ├── resnext50_32x4d.py │ ├── se_resnet101_ibn_a.py │ ├── shufflenet_v2_x0_5.py │ ├── shufflenet_v2_x1_0.py │ ├── shufflenet_v2_x1_5.py │ ├── shufflenet_v2_x2_0.py │ ├── skip │ │ ├── dcgan.py │ │ ├── efficientnet_b0.py │ │ ├── efficientnet_b2.py │ │ ├── efficientnet_b3.py │ │ ├── efficientnet_b4.py │ │ ├── efficientnet_b5.py │ │ ├── efficientnet_b6.py │ │ ├── efficientnet_b7.py │ │ ├── ghostnet.py │ │ ├── ghostnet_1x.py │ │ ├── midas_v3_hybrid.py │ │ └── vit_h_14.py │ ├── squeezenet1_0.py │ ├── squeezenet1_1.py │ ├── swin_b.py │ ├── swin_s.py │ ├── swin_t.py │ ├── unet.py │ ├── vgg11.py │ ├── vgg11_bn.py │ ├── vgg13.py │ ├── vgg13_bn.py │ ├── vgg16.py │ ├── vgg16_bn.py │ ├── vgg19.py │ ├── vgg19_bn.py │ ├── vit_b_16.py │ ├── vit_b_32.py │ ├── vit_l_16.py │ ├── vit_l_32.py │ ├── wide_resnet101_2.py │ └── wide_resnet50_2.py ├── torchvision │ ├── __init__.py │ ├── fasterrcnn_mobilenet_v3_large_320_fpn.py │ ├── fasterrcnn_mobilenet_v3_large_fpn.py │ ├── fasterrcnn_resnet50_fpn_v2.py │ ├── fcos_resnet50_fpn.py │ ├── maskrcnn_resnet50_fpn_v2.py │ ├── retinanet_resnet50_fpn_v2.py │ └── skip │ │ ├── fasterrcnn_resnet50_fpn.py │ │ ├── keypointrcnn_resnet50_fpn.py │ │ ├── maskrcnn_resnet50_fpn.py │ │ ├── retinanet_resnet50_fpn.py │ │ ├── ssd300_vgg16.py │ │ └── ssdlite320_mobilenet_v3_large.py └── transformers │ ├── __init__.py │ ├── albert.py │ ├── albert_base_v1.py │ ├── albert_large_v1.py │ ├── albert_large_v2.py │ ├── albert_xlarge_v1.py │ ├── albert_xlarge_v2.py │ ├── albert_xxlarge_v1.py │ ├── albert_xxlarge_v2.py │ ├── auto.py │ ├── bart.py │ ├── bart_large.py │ ├── barthez.py │ ├── barthez_classification.py │ ├── barthez_summarization.py │ ├── bartpho_syllable.py │ ├── bartpho_syllable_base.py │ ├── bartpho_word.py │ ├── bartpho_word_base.py │ ├── bert.py │ ├── bert_large.py │ ├── bertjapanese.py │ ├── bertjapanese_large.py │ ├── bertlmhead.py │ ├── bertweet.py │ ├── bertweet_large.py │ ├── bigbird.py │ ├── bigbirdpegasus.py │ ├── biogpt.py │ ├── biogpt_large.py │ ├── blenderbot.py │ ├── blenderbotsmall.py │ ├── bloom.py │ ├── bloom_1b1.py │ ├── bloom_1b7.py │ ├── bloom_3b.py │ ├── bloom_7b1.py │ ├── camembert.py │ ├── camembert_large.py │ ├── canine.py │ ├── codegen.py │ ├── codegen_350m.py │ ├── codegen_6b.py │ ├── convbert.py │ ├── convbert_medium_small.py │ ├── convbert_small.py │ ├── ctrl.py │ ├── ctrllmhead.py │ ├── deberta.py │ ├── deberta_large.py │ ├── deberta_xlarge.py │ ├── debertav2.py │ ├── debertav2_xxlarge.py │ ├── debertav3_base.py │ ├── debertav3_large.py │ ├── debertav3_small.py │ ├── debertav3_xsmall.py │ ├── distilbert.py │ ├── dpr_context_encoder.py │ ├── dpr_question_encoder.py │ ├── dpr_reader.py │ ├── electra.py │ ├── electra_base.py │ ├── electra_generator_base.py │ ├── electra_generator_large.py │ ├── electra_generator_small.py │ ├── electra_large.py │ ├── encoderdecoder.py │ ├── ernie.py │ ├── ernie2_base.py │ ├── ernie2_large.py │ ├── ernie3_base.py │ ├── ernie3_medium.py │ ├── ernie3_micro.py │ ├── ernie3_mini.py │ ├── ernie3_nano.py │ ├── ernie_health.py │ ├── erniem.py │ ├── erniem_large.py │ ├── esm.py │ ├── esm2_150M.py │ ├── esm2_15B.py │ ├── esm2_35M.py │ ├── esm2_3B.py │ ├── esm2_650M.py │ ├── falcon.py │ ├── falcon_40b.py │ ├── falcon_7b.py │ ├── flaubert.py │ ├── flaubert_large.py │ ├── flaubert_small.py │ ├── flaubertwithlmhead.py │ ├── flaubertwithlmhead_large.py │ ├── flaubertwithlmhead_small.py │ ├── fnet.py │ ├── fnet_large.py │ ├── fsmt.py │ ├── fsmt_de_en.py │ ├── fsmt_en_de.py │ ├── fsmt_en_ru.py │ ├── funnel.py │ ├── funnel_intermediate.py │ ├── funnel_intermediate_base.py │ ├── funnel_large.py │ ├── funnel_large_base.py │ ├── funnel_medium.py │ ├── funnel_medium_base.py │ ├── funnel_small_base.py │ ├── funnel_xlarge.py │ ├── funnel_xlarge_base.py │ ├── gpt2.py │ ├── gpt2doubleheads.py │ ├── gpt2lmhead.py │ ├── gptbigcode.py │ ├── gptj.py │ ├── gptj_tiny.py │ ├── gptneo.py │ ├── gptneo_125M.py │ ├── gptneo_2B7.py │ ├── gptneox.py │ ├── gptneoxjapanese.py │ ├── ibert.py │ ├── ibert_large.py │ ├── led.py │ ├── led_large.py │ ├── llama2_13b.py │ ├── llama2_34b.py │ ├── llama2_70b.py │ ├── llama2_7b.py │ ├── longformer.py │ ├── longformer_large.py │ ├── longt5.py │ ├── longt5_large.py │ ├── longt5_tglobal_base.py │ ├── longt5_tglobal_large.py │ ├── longt5_tglobal_xl.py │ ├── longt5encoder.py │ ├── luke.py │ ├── luke_base_lite.py │ ├── luke_japanese_base.py │ ├── luke_japanese_base_lite.py │ ├── luke_japanese_large.py │ ├── luke_japanese_large_lite.py │ ├── luke_large.py │ ├── luke_large_lite.py │ ├── m2m100.py │ ├── m2m100_12B.py │ ├── m2m100_1B2.py │ ├── madlad400_10b.py │ ├── madlad400_3b.py │ ├── madlad400_7b.py │ ├── marian.py │ ├── markuplm.py │ ├── markuplm_large.py │ ├── mbart.py │ ├── mbart_50.py │ ├── mbarthez.py │ ├── mega.py │ ├── mistral_7b.py │ ├── mixtral_7bx8.py │ ├── mluke_base.py │ ├── mluke_base_lite.py │ ├── mluke_large.py │ ├── mluke_large_lite.py │ ├── mobilebert.py │ ├── mpnet.py │ ├── mpt.py │ ├── mpt_30b.py │ ├── mpt_7b_8k.py │ ├── mra.py │ ├── mra_4096.py │ ├── mt5.py │ ├── mt5_base.py │ ├── mt5_large.py │ ├── mt5_xl.py │ ├── mt5_xxl.py │ ├── mt5encoder.py │ ├── mt5encoder_base.py │ ├── mt5encoder_large.py │ ├── mt5encoder_xl.py │ ├── mt5encoder_xxl.py │ ├── mvp.py │ ├── nezha.py │ ├── nezha_large.py │ ├── nystromformer.py │ ├── nystromformer_1024.py │ ├── nystromformer_2048.py │ ├── nystromformer_4096.py │ ├── openaigpt.py │ ├── openaigptdoubleheads.py │ ├── openaigptlmhead.py │ ├── opt.py │ ├── opt_125m.py │ ├── opt_13B.py │ ├── opt_1B3.py │ ├── opt_2B7.py │ ├── opt_30B.py │ ├── opt_66B.py │ ├── opt_6B7.py │ ├── pegasus_base.py │ ├── pegasus_large.py │ ├── pegasus_x_base.py │ ├── pegasus_x_large.py │ ├── persimmon_8b.py │ ├── phi1.py │ ├── phi1point5.py │ ├── phi2.py │ ├── phobert_base.py │ ├── phobert_large.py │ ├── plbart.py │ ├── plbart_large.py │ ├── prophetnet.py │ ├── reformer.py │ ├── rembert.py │ ├── roberta.py │ ├── roberta_large.py │ ├── robertaprelayernorm.py │ ├── rocbert.py │ ├── roformer.py │ ├── roformer_small.py │ ├── skip │ ├── jukebox.py │ ├── qdqbert.py │ ├── qdqbertlmhead.py │ ├── rag.py │ └── rwkv.py │ ├── splinter.py │ ├── splinter_large.py │ ├── squeezebert.py │ ├── switchtransformers.py │ ├── switchtransformers_base_128.py │ ├── switchtransformers_base_16.py │ ├── switchtransformers_base_256.py │ ├── switchtransformers_base_32.py │ ├── switchtransformers_base_64.py │ ├── switchtransformers_large.py │ ├── switchtransformers_xxl.py │ ├── switchtransformersencoder.py │ ├── switchtransformersencoder_base_128.py │ ├── switchtransformersencoder_base_16.py │ ├── switchtransformersencoder_base_256.py │ ├── switchtransformersencoder_base_32.py │ ├── switchtransformersencoder_base_64.py │ ├── switchtransformersencoder_large.py │ ├── switchtransformersencoder_xxl.py │ ├── t5.py │ ├── t5_11b.py │ ├── t5_3b.py │ ├── t5_base.py │ ├── t5_large.py │ ├── t5encoder.py │ ├── t5encoder_11b.py │ ├── t5encoder_3b.py │ ├── t5encoder_base.py │ ├── t5encoder_large.py │ ├── t5v1dot1_base.py │ ├── t5v1dot1_large.py │ ├── t5v1dot1_small.py │ ├── t5v1dot1_xl.py │ ├── t5v1dot1_xxl.py │ ├── transfoxl.py │ ├── transfoxllmhead.py │ ├── umt5.py │ ├── umt5_base.py │ ├── umt5_xl.py │ ├── umt5_xxl.py │ ├── umt5encoder.py │ ├── umt5encoder_base.py │ ├── umt5encoder_xl.py │ ├── umt5encoder_xxl.py │ ├── xglm.py │ ├── xglm_1B7.py │ ├── xglm_2B9.py │ ├── xglm_4B5.py │ ├── xglm_7B5.py │ ├── xlm.py │ ├── xlm_1024.py │ ├── xlm_1280.py │ ├── xlmroberta.py │ ├── xlmroberta_large.py │ ├── xlmrobertaxl.py │ ├── xlmrobertaxl_xxl.py │ ├── xlmv.py │ ├── xlmwithlmhead.py │ ├── xlmwithlmhead_1024.py │ ├── xlmwithlmhead_1280.py │ ├── xlnet.py │ ├── xlnet_large.py │ ├── xlnetlmhead.py │ ├── xlnetlmhead_base.py │ ├── xmod.py │ ├── xmod_base_13_125k.py │ ├── xmod_base_30_125k.py │ ├── xmod_base_30_195k.py │ ├── xmod_base_60_125k.py │ ├── xmod_base_60_265k.py │ ├── xmod_base_75_125k.py │ ├── xmod_base_75_269k.py │ ├── xmod_large.py │ └── yoso.py ├── plugins ├── README.md └── devices │ ├── README.md │ ├── setup.py │ ├── src │ └── turnkeyml_plugin_devices │ │ ├── __init__.py │ │ ├── common │ │ ├── __init__.py │ │ ├── run │ │ │ ├── __init__.py │ │ │ ├── basert.py │ │ │ ├── benchmark_model.py │ │ │ ├── devices.py │ │ │ ├── performance.py │ │ │ └── plugin_helpers.py │ │ └── util.py │ │ ├── onnxrt │ │ ├── __init__.py │ │ ├── execute.py │ │ ├── runtime.py │ │ └── within_conda.py │ │ ├── tensorrt │ │ ├── __init__.py │ │ ├── execute.py │ │ └── runtime.py │ │ └── torchrt │ │ ├── __init__.py │ │ └── runtime.py │ └── test │ ├── benchmark.py │ └── unit.py ├── pyproject.toml ├── setup.py ├── src ├── lemonade │ ├── __init__.py │ ├── api.py │ ├── cache.py │ ├── cli.py │ └── tools │ │ ├── __init__.py │ │ ├── adapter.py │ │ ├── bench.py │ │ ├── huggingface_bench.py │ │ ├── huggingface_load.py │ │ ├── humaneval.py │ │ ├── llamacpp.py │ │ ├── llamacpp_bench.py │ │ ├── mmlu.py │ │ ├── ort_genai │ │ ├── __init__.py │ │ ├── oga.py │ │ └── oga_bench.py │ │ ├── perplexity.py │ │ ├── prompt.py │ │ ├── quark │ │ ├── __init__.py │ │ ├── quark_load.py │ │ └── quark_quantize.py │ │ ├── report │ │ ├── __init__.py │ │ ├── llm_report.py │ │ └── table.py │ │ └── server │ │ ├── serve.py │ │ └── tool_calls.py ├── lemonade_install │ ├── __init__.py │ └── install.py ├── lemonade_server │ ├── cli.py │ ├── model_manager.py │ └── server_models.json └── turnkeyml │ ├── __init__.py │ ├── cli │ ├── __init__.py │ ├── cli.py │ ├── login.py │ ├── parser_helpers.py │ ├── run_slurm.sh │ ├── setup_venv.sh │ └── spawn.py │ ├── common │ ├── __init__.py │ ├── analyze_model.py │ ├── build.py │ ├── cli_helpers.py │ ├── exceptions.py │ ├── filesystem.py │ ├── labels.py │ ├── onnx_helpers.py │ ├── plugins.py │ ├── printing.py │ ├── status.py │ ├── system_info.py │ ├── tensor_helpers.py │ └── test_helpers.py │ ├── files_api.py │ ├── memory_tracker.py │ ├── parser.py │ ├── sequence │ ├── __init__.py │ ├── sequence.py │ └── tool_plugins.py │ ├── state.py │ ├── tools │ ├── __init__.py │ ├── discovery │ │ ├── __init__.py │ │ ├── discover.py │ │ └── script.py │ ├── export.py │ ├── load_build.py │ ├── management_tools.py │ ├── onnx.py │ ├── report.py │ └── tool.py │ └── version.py └── test ├── helpers ├── check_slurm_output.sh └── slurm.conf ├── lemonade ├── llm_api.py ├── oga_cpu_api.py ├── quark_api.py ├── server.py ├── server_cli.py └── server_unit.py └── turnkey ├── analysis.py ├── cli.py └── unit.py /.lfsconfig: -------------------------------------------------------------------------------- 1 | [lfs] 2 | fetchexclude = *.onnx,*_model.zip 3 | -------------------------------------------------------------------------------- /docs/versioning.md: -------------------------------------------------------------------------------- 1 | # Versioning Policy 2 | 3 | The `turnkey` package applies semantic versioning for its 3-digit version number. The version number is stored in `src/version.py`. 4 | 5 | The 3 digits correspond to MAJOR.MINOR.PATCH, which can be interpreted as follows: 6 | * MAJOR: changes indicate breaking API changes that may require the user to change their own code 7 | * MINOR: changes indicate that builds against a previous minor version may not be compatible, and the user may need to rebuild those models 8 | * PATCH: no user action required when the patch number changes 9 | -------------------------------------------------------------------------------- /examples/lemonade/demos/README.md: -------------------------------------------------------------------------------- 1 | # Lemonade Demos 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/tree/main/examples/demos 4 | -------------------------------------------------------------------------------- /examples/lemonade/server/README.md: -------------------------------------------------------------------------------- 1 | # Lemonade Server Examples 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/ai-toolkit.md: -------------------------------------------------------------------------------- 1 | # Microsoft AI Toolkit for VS Code 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/anythingLLM.md: -------------------------------------------------------------------------------- 1 | 2 | # Running agents locally with Lemonade and AnythingLLM 3 | 4 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/codeGPT.md: -------------------------------------------------------------------------------- 1 | # CodeGPT with VS Code 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/continue.md: -------------------------------------------------------------------------------- 1 | # Continue Coding Assistant 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/lm-eval.md: -------------------------------------------------------------------------------- 1 | # Using LM-Evaluation-Harness with Lemonade 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/mindcraft.md: -------------------------------------------------------------------------------- 1 | # Mindcraft 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/lemonade/server/wut.md: -------------------------------------------------------------------------------- 1 | # `wut` Terminal Assistant 2 | 3 | This content has moved to: https://github.com/lemonade-sdk/lemonade/blob/main/docs/server/featured_apps.md -------------------------------------------------------------------------------- /examples/readme.md: -------------------------------------------------------------------------------- 1 | # Tool Examples 2 | 3 | This directory contains examples to help you learn how to use the tools. The examples are split up into these sub-directories: 4 | 5 | 1. `examples/lemonade`: demonstrate the Lemonade SDK for LLMs. This includes examples on how to use Lemonade Server with existing applications, as well as examples on using the Lemonade API to integrate LLMs into Python applications. 6 | 1. `examples/turnkey/`: demonstrate TurnkeyML for general ONNX workflows. This includes a tutorial series for the `turnkey` CLI and example scripts showing how to use the `turnkey.files_api.evaluate_files()` API. 7 | -------------------------------------------------------------------------------- /examples/turnkey/README.md: -------------------------------------------------------------------------------- 1 | # TurnkeyML Examples 2 | 3 | 1. `examples/turnkey/cli`: a tutorial series for the `turnkey` CLI. This is the recommended starting point. 4 | 1. `examples/turnkey/api`: scripts that demonstrate how to use the `turnkey.files_api.evaluate_files()` API. -------------------------------------------------------------------------------- /examples/turnkey/cli/onnx/README.md: -------------------------------------------------------------------------------- 1 | # CLI ONNX Examples 2 | 3 | You can try out `turnkey` with an ONNX file input like so: 4 | 5 | ```bash 6 | cd turnkeyml/examples/turnkey/cli/onnx 7 | turnkey -i hello_world.onnx load-onnx convert-fp16` 8 | ``` 9 | 10 | This will convert the example ONNX file to the fp16 data type. 11 | -------------------------------------------------------------------------------- /examples/turnkey/cli/onnx/hello_world.onnx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/examples/turnkey/cli/onnx/hello_world.onnx -------------------------------------------------------------------------------- /examples/turnkey/cli/plugins/example_tool/setup.py: -------------------------------------------------------------------------------- 1 | from setuptools import setup 2 | 3 | setup( 4 | name="turnkeyml_plugin_example_tool", 5 | version="0.0.0", 6 | packages=["turnkeyml_plugin_example_tool"], 7 | python_requires=">=3.8, <3.12", 8 | ) 9 | -------------------------------------------------------------------------------- /examples/turnkey/cli/plugins/example_tool/turnkeyml_plugin_example_tool/__init__.py: -------------------------------------------------------------------------------- 1 | from .tool import ExamplePluginTool 2 | 3 | implements = {"tools": [ExamplePluginTool]} 4 | -------------------------------------------------------------------------------- /examples/turnkey/cli/readme.md: -------------------------------------------------------------------------------- 1 | # CLI Examples 2 | 3 | This folder contains artifacts that can be used to help learn the `turnkey` CLI. See the docstring in each Python script for more information about how it can be used. 4 | 5 | - [`onnx/`](https://github.com/onnx/turnkeyml/blob/main/examples/turnkey/cli/onnx/README.md): example input for the `turnkey load-onnx` tool. 6 | - [`plugins/`](https://github.com/onnx/turnkeyml/blob/main/examples/turnkey/cli/plugins/README.md): example plugin implementation code. 7 | - [`scripts/`](https://github.com/onnx/turnkeyml/blob/main/examples/turnkey/cli/scripts/README.md): example scripts for use with the `turnkey discover` tool. 8 | -------------------------------------------------------------------------------- /img/basic_demo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/img/basic_demo.gif -------------------------------------------------------------------------------- /img/classic_demo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/img/classic_demo.png -------------------------------------------------------------------------------- /img/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/img/favicon.ico -------------------------------------------------------------------------------- /img/llm_demo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/img/llm_demo.png -------------------------------------------------------------------------------- /models/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/__init__.py -------------------------------------------------------------------------------- /models/graph_convolutions/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/graph_convolutions/__init__.py -------------------------------------------------------------------------------- /models/log.yml: -------------------------------------------------------------------------------- 1 | # This file is a log of any destrutive changes that have been made to the 2 | # turnkey models corpus. 3 | 4 | # models_renamed is a dictionary of dictionaries. At the top level, the keys 5 | # are the corpus names. At the leaf level, the keys are original model names 6 | # and the values are the new model names. 7 | # models_deleted is a list of models that have been removed from the corpus 8 | 9 | models_renamed: 10 | - transformers 11 | - funnelbase : funnel_small_base 12 | - luke : mluke_base 13 | - pegasus : pegasus_x_large 14 | - gptj : gptj_tiny 15 | models_deleted: 16 | - None -------------------------------------------------------------------------------- /models/requirements.txt: -------------------------------------------------------------------------------- 1 | sentence-transformers 2 | pandas 3 | simpletransformers 4 | roformer 5 | torch>=1.12.1 6 | datasets>=2.3.2 7 | torchvision>=0.11.3 8 | torchaudio>=0.10.2 9 | torch_geometric>=2.3.0 10 | transformers>=4.21.0 11 | pytorch-pretrained-biggan>=0.1.1 12 | timm>=0.6.7 13 | diffusers>=0.2.4, <=0.12 14 | requests 15 | Pillow 16 | nltk 17 | sentence_transformers 18 | scipy 19 | numpy 20 | timm 21 | fvcore 22 | sacremoses 23 | sentencepiece 24 | -------------------------------------------------------------------------------- /models/selftest/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/selftest/__init__.py -------------------------------------------------------------------------------- /models/timm/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/timm/__init__.py -------------------------------------------------------------------------------- /models/timm/botnet26t_256.py: -------------------------------------------------------------------------------- 1 | # labels: name::botnet26t_256 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("botnet26t_256", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cait_m36_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::cait_m36_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cait_m36_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cait_m48_448.py: -------------------------------------------------------------------------------- 1 | # labels: name::cait_m48_448 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cait_m48_448", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cait_s24_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::cait_s24_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cait_s24_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cait_s24_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::cait_s24_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cait_s24_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cait_s36_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::cait_s36_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cait_s36_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cait_xs24_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::cait_xs24_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cait_xs24_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/coat_mini.py: -------------------------------------------------------------------------------- 1 | # labels: name::coat_mini author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("coat_mini", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/coat_tiny.py: -------------------------------------------------------------------------------- 1 | # labels: name::coat_tiny author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("coat_tiny", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/convit_base.py: -------------------------------------------------------------------------------- 1 | # labels: name::convit_base author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("convit_base", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/convit_small.py: -------------------------------------------------------------------------------- 1 | # labels: name::convit_small author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("convit_small", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/convit_tiny.py: -------------------------------------------------------------------------------- 1 | # labels: name::convit_tiny author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("convit_tiny", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/convnext_base.py: -------------------------------------------------------------------------------- 1 | # labels: name::convnext_base author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("convnext_base", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/convnext_nano.py: -------------------------------------------------------------------------------- 1 | # labels: name::convnext_nano author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("convnext_nano", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/convnext_tiny.py: -------------------------------------------------------------------------------- 1 | # labels: name::convnext_tiny author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("convnext_tiny", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cs3darknet_l.py: -------------------------------------------------------------------------------- 1 | # labels: name::cs3darknet_l author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cs3darknet_l", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cs3darknet_m.py: -------------------------------------------------------------------------------- 1 | # labels: name::cs3darknet_m author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cs3darknet_m", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cs3darknet_s.py: -------------------------------------------------------------------------------- 1 | # labels: name::cs3darknet_s author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cs3darknet_s", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cs3darknet_x.py: -------------------------------------------------------------------------------- 1 | # labels: name::cs3darknet_x author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cs3darknet_x", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cs3edgenet_x.py: -------------------------------------------------------------------------------- 1 | # labels: name::cs3edgenet_x author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cs3edgenet_x", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cspdarknet53.py: -------------------------------------------------------------------------------- 1 | # labels: name::cspdarknet53 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cspdarknet53", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cspresnet50.py: -------------------------------------------------------------------------------- 1 | # labels: name::cspresnet50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cspresnet50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cspresnet50d.py: -------------------------------------------------------------------------------- 1 | # labels: name::cspresnet50d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cspresnet50d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cspresnet50w.py: -------------------------------------------------------------------------------- 1 | # labels: name::cspresnet50w author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cspresnet50w", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/cspresnext50.py: -------------------------------------------------------------------------------- 1 | # labels: name::cspresnext50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("cspresnext50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/darknet17.py: -------------------------------------------------------------------------------- 1 | # labels: name::darknet17 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("darknet17", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/darknet21.py: -------------------------------------------------------------------------------- 1 | # labels: name::darknet21 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("darknet21", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/darknet53.py: -------------------------------------------------------------------------------- 1 | # labels: name::darknet53 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("darknet53", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/darknetaa53.py: -------------------------------------------------------------------------------- 1 | # labels: name::darknetaa53 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("darknetaa53", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/densenet121.py: -------------------------------------------------------------------------------- 1 | # labels: name::densenet121 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("densenet121", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/densenet161.py: -------------------------------------------------------------------------------- 1 | # labels: name::densenet161 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("densenet161", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/densenet169.py: -------------------------------------------------------------------------------- 1 | # labels: name::densenet169 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("densenet169", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/densenet201.py: -------------------------------------------------------------------------------- 1 | # labels: name::densenet201 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("densenet201", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla102.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla102 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla102", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla102x.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla102x author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla102x", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla102x2.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla102x2 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla102x2", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla169.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla169 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla169", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla34.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla34 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla34", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla46_c.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla46_c author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla46_c", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla46x_c.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla46x_c author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla46x_c", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla60.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla60 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla60", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla60_res2net.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla60_res2net author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla60_res2net", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla60x.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla60x author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla60x", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dla60x_c.py: -------------------------------------------------------------------------------- 1 | # labels: name::dla60x_c author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dla60x_c", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f0.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f0 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f0", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f1.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f2.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f2 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f2", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f3.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f3 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f3", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f4.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f4 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f4", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f5.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f5 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f5", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dm_nfnet_f6.py: -------------------------------------------------------------------------------- 1 | # labels: name::dm_nfnet_f6 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dm_nfnet_f6", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dpn107.py: -------------------------------------------------------------------------------- 1 | # labels: name::dpn107 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dpn107", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dpn131.py: -------------------------------------------------------------------------------- 1 | # labels: name::dpn131 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dpn131", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dpn68.py: -------------------------------------------------------------------------------- 1 | # labels: name::dpn68 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dpn68", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dpn68b.py: -------------------------------------------------------------------------------- 1 | # labels: name::dpn68b author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dpn68b", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dpn92.py: -------------------------------------------------------------------------------- 1 | # labels: name::dpn92 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dpn92", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/dpn98.py: -------------------------------------------------------------------------------- 1 | # labels: name::dpn98 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("dpn98", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/eca_nfnet_l0.py: -------------------------------------------------------------------------------- 1 | # labels: name::eca_nfnet_l0 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("eca_nfnet_l0", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/eca_nfnet_l1.py: -------------------------------------------------------------------------------- 1 | # labels: name::eca_nfnet_l1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("eca_nfnet_l1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/fbnetc_100.py: -------------------------------------------------------------------------------- 1 | # labels: name::fbnetc_100 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("fbnetc_100", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/fbnetv3_b.py: -------------------------------------------------------------------------------- 1 | # labels: name::fbnetv3_b author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("fbnetv3_b", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/fbnetv3_d.py: -------------------------------------------------------------------------------- 1 | # labels: name::fbnetv3_d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("fbnetv3_d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/fbnetv3_g.py: -------------------------------------------------------------------------------- 1 | # labels: name::fbnetv3_g author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("fbnetv3_g", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/gcresnet50t.py: -------------------------------------------------------------------------------- 1 | # labels: name::gcresnet50t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("gcresnet50t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/gernet_l.py: -------------------------------------------------------------------------------- 1 | # labels: name::gernet_l author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("gernet_l", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/gernet_m.py: -------------------------------------------------------------------------------- 1 | # labels: name::gernet_m author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("gernet_m", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/gernet_s.py: -------------------------------------------------------------------------------- 1 | # labels: name::gernet_s author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("gernet_s", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/halonet26t.py: -------------------------------------------------------------------------------- 1 | # labels: name::halonet26t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("halonet26t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/halonet50ts.py: -------------------------------------------------------------------------------- 1 | # labels: name::halonet50ts author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("halonet50ts", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/halonet_h1.py: -------------------------------------------------------------------------------- 1 | # labels: name::halonet_h1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("halonet_h1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w18.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w18 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w18", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w30.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w30 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w30", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w32.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w32 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w32", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w40.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w40 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w40", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w44.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w44 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w44", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w48.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w48 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w48", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/hrnet_w64.py: -------------------------------------------------------------------------------- 1 | # labels: name::hrnet_w64 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("hrnet_w64", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/lcnet_035.py: -------------------------------------------------------------------------------- 1 | # labels: name::lcnet_035 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("lcnet_035", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/lcnet_050.py: -------------------------------------------------------------------------------- 1 | # labels: name::lcnet_050 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("lcnet_050", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/lcnet_075.py: -------------------------------------------------------------------------------- 1 | # labels: name::lcnet_075 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("lcnet_075", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/lcnet_100.py: -------------------------------------------------------------------------------- 1 | # labels: name::lcnet_100 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("lcnet_100", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/lcnet_150.py: -------------------------------------------------------------------------------- 1 | # labels: name::lcnet_150 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("lcnet_150", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/levit_128.py: -------------------------------------------------------------------------------- 1 | # labels: name::levit_128 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("levit_128", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/levit_128s.py: -------------------------------------------------------------------------------- 1 | # labels: name::levit_128s author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("levit_128s", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/levit_192.py: -------------------------------------------------------------------------------- 1 | # labels: name::levit_192 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("levit_192", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/levit_256.py: -------------------------------------------------------------------------------- 1 | # labels: name::levit_256 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("levit_256", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/levit_256d.py: -------------------------------------------------------------------------------- 1 | # labels: name::levit_256d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("levit_256d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/levit_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::levit_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("levit_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mixnet_l.py: -------------------------------------------------------------------------------- 1 | # labels: name::mixnet_l author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mixnet_l", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mixnet_m.py: -------------------------------------------------------------------------------- 1 | # labels: name::mixnet_m author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mixnet_m", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mixnet_s.py: -------------------------------------------------------------------------------- 1 | # labels: name::mixnet_s author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mixnet_s", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mixnet_xl.py: -------------------------------------------------------------------------------- 1 | # labels: name::mixnet_xl author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mixnet_xl", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mixnet_xxl.py: -------------------------------------------------------------------------------- 1 | # labels: name::mixnet_xxl author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mixnet_xxl", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mnasnet_050.py: -------------------------------------------------------------------------------- 1 | # labels: name::mnasnet_050 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mnasnet_050", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mnasnet_075.py: -------------------------------------------------------------------------------- 1 | # labels: name::mnasnet_075 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mnasnet_075", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mnasnet_100.py: -------------------------------------------------------------------------------- 1 | # labels: name::mnasnet_100 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mnasnet_100", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mnasnet_140.py: -------------------------------------------------------------------------------- 1 | # labels: name::mnasnet_140 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mnasnet_140", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mnasnet_a1.py: -------------------------------------------------------------------------------- 1 | # labels: name::mnasnet_a1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mnasnet_a1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mnasnet_b1.py: -------------------------------------------------------------------------------- 1 | # labels: name::mnasnet_b1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mnasnet_b1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/mobilevit_s.py: -------------------------------------------------------------------------------- 1 | # labels: name::mobilevit_s author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("mobilevit_s", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nest_base.py: -------------------------------------------------------------------------------- 1 | # labels: name::nest_base author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nest_base", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nest_small.py: -------------------------------------------------------------------------------- 1 | # labels: name::nest_small author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nest_small", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nest_tiny.py: -------------------------------------------------------------------------------- 1 | # labels: name::nest_tiny author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nest_tiny", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nf_resnet26.py: -------------------------------------------------------------------------------- 1 | # labels: name::nf_resnet26 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nf_resnet26", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nf_resnet50.py: -------------------------------------------------------------------------------- 1 | # labels: name::nf_resnet50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nf_resnet50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f0.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f0 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f0", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f1.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f2.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f2 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f2", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f3.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f3 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f3", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f4.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f4 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f4", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f5.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f5 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f5", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f6.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f6 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f6", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_f7.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_f7 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_f7", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/nfnet_l0.py: -------------------------------------------------------------------------------- 1 | # labels: name::nfnet_l0 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("nfnet_l0", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/pit_b_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::pit_b_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("pit_b_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/pit_s_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::pit_s_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("pit_s_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/pit_ti_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::pit_ti_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("pit_ti_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/pit_xs_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::pit_xs_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("pit_xs_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetv_040.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetv_040 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetv_040", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetv_064.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetv_064 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetv_064", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_002.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_002 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_002", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_004.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_004 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_004", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_006.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_006 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_006", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_008.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_008 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_008", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_016.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_016 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_016", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_032.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_032 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_032", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_040.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_040 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_040", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_064.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_064 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_064", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_080.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_080 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_080", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_120.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_120 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_120", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_160.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_160 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_160", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetx_320.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetx_320 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetx_320", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_002.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_002 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_002", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_004.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_004 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_004", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_006.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_006 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_006", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_008.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_008 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_008", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_016.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_016 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_016", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_032.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_032 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_032", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_040.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_040 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_040", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_064.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_064 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_064", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_080.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_080 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_080", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_120.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_120 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_120", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_160.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_160 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_160", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnety_320.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnety_320 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnety_320", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_005.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_005 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_005", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_040.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_040 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_040", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_b16.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_b16 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_b16", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_c16.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_c16 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_c16", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_d32.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_d32 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_d32", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_d8.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_d8 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_d8", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/regnetz_e8.py: -------------------------------------------------------------------------------- 1 | # labels: name::regnetz_e8 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("regnetz_e8", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_a2.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_a2 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_a2", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b0.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b0 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b0", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b1.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b1 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b1", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b1g4.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b1g4 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b1g4", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b2.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b2 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b2", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b2g4.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b2g4 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b2g4", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b3.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b3 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b3", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/repvgg_b3g4.py: -------------------------------------------------------------------------------- 1 | # labels: name::repvgg_b3g4 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("repvgg_b3g4", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/res2next50.py: -------------------------------------------------------------------------------- 1 | # labels: name::res2next50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("res2next50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnest101e.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnest101e author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnest101e", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnest14d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnest14d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnest14d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnest200e.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnest200e author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnest200e", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnest269e.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnest269e author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnest269e", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnest26d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnest26d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnest26d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnest50d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnest50d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnest50d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet101.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet101 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet101", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet101d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet101d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet101d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet10t.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet10t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet10t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet14t.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet14t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet14t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet152.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet152 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet152", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet152d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet152d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet152d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet18.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet18 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet18", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet18d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet18d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet18d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet200.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet200 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet200", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet200d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet200d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet200d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet26.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet26 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet26", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet26d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet26d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet26d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet26t.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet26t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet26t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet32ts.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet32ts author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet32ts", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet33ts.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet33ts author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet33ts", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet34.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet34 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet34", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet34d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet34d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet34d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet50.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet50_gn.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet50_gn author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet50_gn", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet50d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet50d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet50d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet50t.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet50t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet50t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet51q.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet51q author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet51q", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnet61q.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnet61q author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnet61q", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetaa50.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetaa50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetaa50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetaa50d.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetaa50d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetaa50d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs101.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs101 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs101", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs152.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs152 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs152", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs200.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs200 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs200", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs270.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs270 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs270", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs350.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs350 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs350", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs420.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs420 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs420", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetrs50.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetrs50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetrs50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnetv2_50.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnetv2_50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnetv2_50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/resnext26ts.py: -------------------------------------------------------------------------------- 1 | # labels: name::resnext26ts author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("resnext26ts", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnet_100.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnet_100 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnet_100", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnet_130.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnet_130 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnet_130", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnet_150.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnet_150 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnet_150", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnet_200.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnet_200 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnet_200", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnetr_100.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnetr_100 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnetr_100", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnetr_130.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnetr_130 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnetr_130", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnetr_150.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnetr_150 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnetr_150", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/rexnetr_200.py: -------------------------------------------------------------------------------- 1 | # labels: name::rexnetr_200 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("rexnetr_200", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/sedarknet21.py: -------------------------------------------------------------------------------- 1 | # labels: name::sedarknet21 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("sedarknet21", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/selecsls42.py: -------------------------------------------------------------------------------- 1 | # labels: name::selecsls42 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("selecsls42", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/selecsls42b.py: -------------------------------------------------------------------------------- 1 | # labels: name::selecsls42b author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("selecsls42b", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/selecsls60.py: -------------------------------------------------------------------------------- 1 | # labels: name::selecsls60 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("selecsls60", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/selecsls60b.py: -------------------------------------------------------------------------------- 1 | # labels: name::selecsls60b author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("selecsls60b", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/selecsls84.py: -------------------------------------------------------------------------------- 1 | # labels: name::selecsls84 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("selecsls84", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/senet154.py: -------------------------------------------------------------------------------- 1 | # labels: name::senet154 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("senet154", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/seresnet101.py: -------------------------------------------------------------------------------- 1 | # labels: name::seresnet101 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("seresnet101", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/seresnet152.py: -------------------------------------------------------------------------------- 1 | # labels: name::seresnet152 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("seresnet152", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/seresnet18.py: -------------------------------------------------------------------------------- 1 | # labels: name::seresnet18 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("seresnet18", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/seresnet34.py: -------------------------------------------------------------------------------- 1 | # labels: name::seresnet34 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("seresnet34", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/seresnet50.py: -------------------------------------------------------------------------------- 1 | # labels: name::seresnet50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("seresnet50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/seresnet50t.py: -------------------------------------------------------------------------------- 1 | # labels: name::seresnet50t author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("seresnet50t", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/skresnet18.py: -------------------------------------------------------------------------------- 1 | # labels: name::skresnet18 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("skresnet18", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/skresnet34.py: -------------------------------------------------------------------------------- 1 | # labels: name::skresnet34 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("skresnet34", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/skresnet50.py: -------------------------------------------------------------------------------- 1 | # labels: name::skresnet50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("skresnet50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/skresnet50d.py: -------------------------------------------------------------------------------- 1 | # labels: name::skresnet50d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("skresnet50d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tf_mixnet_l.py: -------------------------------------------------------------------------------- 1 | # labels: name::tf_mixnet_l author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tf_mixnet_l", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tf_mixnet_m.py: -------------------------------------------------------------------------------- 1 | # labels: name::tf_mixnet_m author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tf_mixnet_m", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tf_mixnet_s.py: -------------------------------------------------------------------------------- 1 | # labels: name::tf_mixnet_s author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tf_mixnet_s", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tinynet_a.py: -------------------------------------------------------------------------------- 1 | # labels: name::tinynet_a author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tinynet_a", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tinynet_b.py: -------------------------------------------------------------------------------- 1 | # labels: name::tinynet_b author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tinynet_b", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tinynet_c.py: -------------------------------------------------------------------------------- 1 | # labels: name::tinynet_c author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tinynet_c", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tinynet_d.py: -------------------------------------------------------------------------------- 1 | # labels: name::tinynet_d author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tinynet_d", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tinynet_e.py: -------------------------------------------------------------------------------- 1 | # labels: name::tinynet_e author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tinynet_e", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tv_resnet34.py: -------------------------------------------------------------------------------- 1 | # labels: name::tv_resnet34 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tv_resnet34", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/tv_resnet50.py: -------------------------------------------------------------------------------- 1 | # labels: name::tv_resnet50 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("tv_resnet50", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg11.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg11 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg11", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg11_bn.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg11_bn author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg11_bn", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg13.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg13 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg13", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg13_bn.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg13_bn author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg13_bn", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg16.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg16 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg16", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg16_bn.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg16_bn author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg16_bn", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg19.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg19 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg19", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vgg19_bn.py: -------------------------------------------------------------------------------- 1 | # labels: name::vgg19_bn author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vgg19_bn", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d1_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d1_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d1_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d1_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d1_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d1_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d2_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d2_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d2_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d2_384.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d2_384 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d2_384", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d3_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d3_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d3_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d3_448.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d3_448 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d3_448", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d4_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d4_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d4_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d4_448.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d4_448 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d4_448", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d5_224.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d5_224 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d5_224", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d5_448.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d5_448 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d5_448", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/volo_d5_512.py: -------------------------------------------------------------------------------- 1 | # labels: name::volo_d5_512 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("volo_d5_512", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vovnet39a.py: -------------------------------------------------------------------------------- 1 | # labels: name::vovnet39a author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vovnet39a", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/vovnet57a.py: -------------------------------------------------------------------------------- 1 | # labels: name::vovnet57a author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("vovnet57a", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/xception.py: -------------------------------------------------------------------------------- 1 | # labels: name::xception author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("xception", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/xception41.py: -------------------------------------------------------------------------------- 1 | # labels: name::xception41 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("xception41", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/xception41p.py: -------------------------------------------------------------------------------- 1 | # labels: name::xception41p author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("xception41p", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/xception65.py: -------------------------------------------------------------------------------- 1 | # labels: name::xception65 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("xception65", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/xception65p.py: -------------------------------------------------------------------------------- 1 | # labels: name::xception65p author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("xception65p", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/timm/xception71.py: -------------------------------------------------------------------------------- 1 | # labels: name::xception71 author::timm task::Computer_Vision license::apache-2.0 2 | import torch 3 | import timm 4 | from turnkeyml.parser import parse 5 | 6 | torch.manual_seed(0) 7 | 8 | # Parsing command-line arguments 9 | batch_size, pretrained = parse(["batch_size", "pretrained"]) 10 | 11 | # Creating model and set it to evaluation mode 12 | model = timm.create_model("xception71", pretrained = pretrained) 13 | model.eval() 14 | 15 | # Creating inputs 16 | input_size = model.default_cfg["input_size"] 17 | batched_input_size = (batch_size,) + input_size 18 | inputs = torch.rand(batched_input_size) 19 | 20 | # Calling model 21 | model(inputs) 22 | -------------------------------------------------------------------------------- /models/torch_hub/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/torch_hub/__init__.py -------------------------------------------------------------------------------- /models/torch_hub/skip/dcgan.py: -------------------------------------------------------------------------------- 1 | # labels: test_group::turnkey name::dcgan author::torch_hub task::Generative_AI license::bsd-3-clause 2 | """https://pytorch.org/hub/facebookresearch_pytorch-gan-zoo_dcgan/""" 3 | 4 | from turnkeyml.parser import parse 5 | import torch 6 | 7 | # Parsing command-line arguments 8 | batch_size = parse(["batch_size"]) 9 | noise_dim = 128 10 | 11 | # Model and input configurations 12 | model = torch.hub.load("facebookresearch/pytorch_GAN_zoo:hub", "DCGAN", pretrained=True) 13 | 14 | inputs = {"z": torch.ones([batch_size, noise_dim], dtype=torch.float)} 15 | 16 | 17 | # Call model 18 | model(**inputs) 19 | -------------------------------------------------------------------------------- /models/torchvision/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/torchvision/__init__.py -------------------------------------------------------------------------------- /models/transformers/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/models/transformers/__init__.py -------------------------------------------------------------------------------- /plugins/devices/src/turnkeyml_plugin_devices/common/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/plugins/devices/src/turnkeyml_plugin_devices/common/__init__.py -------------------------------------------------------------------------------- /plugins/devices/src/turnkeyml_plugin_devices/common/run/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/plugins/devices/src/turnkeyml_plugin_devices/common/run/__init__.py -------------------------------------------------------------------------------- /plugins/devices/src/turnkeyml_plugin_devices/onnxrt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/plugins/devices/src/turnkeyml_plugin_devices/onnxrt/__init__.py -------------------------------------------------------------------------------- /plugins/devices/src/turnkeyml_plugin_devices/tensorrt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/plugins/devices/src/turnkeyml_plugin_devices/tensorrt/__init__.py -------------------------------------------------------------------------------- /plugins/devices/src/turnkeyml_plugin_devices/torchrt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/plugins/devices/src/turnkeyml_plugin_devices/torchrt/__init__.py -------------------------------------------------------------------------------- /pyproject.toml: -------------------------------------------------------------------------------- 1 | [build-system] 2 | requires = ["setuptools>=61.0"] 3 | build-backend = "setuptools.build_meta" -------------------------------------------------------------------------------- /src/lemonade/__init__.py: -------------------------------------------------------------------------------- 1 | from .cli import main as lemonadecli 2 | -------------------------------------------------------------------------------- /src/lemonade/tools/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/src/lemonade/tools/__init__.py -------------------------------------------------------------------------------- /src/lemonade/tools/ort_genai/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/src/lemonade/tools/ort_genai/__init__.py -------------------------------------------------------------------------------- /src/lemonade/tools/quark/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/src/lemonade/tools/quark/__init__.py -------------------------------------------------------------------------------- /src/lemonade/tools/report/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/src/lemonade/tools/report/__init__.py -------------------------------------------------------------------------------- /src/lemonade_install/__init__.py: -------------------------------------------------------------------------------- 1 | from .install import main as installcli 2 | -------------------------------------------------------------------------------- /src/turnkeyml/__init__.py: -------------------------------------------------------------------------------- 1 | from turnkeyml.version import __version__ 2 | 3 | from .state import load_state, State 4 | -------------------------------------------------------------------------------- /src/turnkeyml/cli/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/src/turnkeyml/cli/__init__.py -------------------------------------------------------------------------------- /src/turnkeyml/common/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/onnx/turnkeyml/25eba0f9b5ae7ee7c785451326e1ced7667b44d1/src/turnkeyml/common/__init__.py -------------------------------------------------------------------------------- /src/turnkeyml/common/plugins.py: -------------------------------------------------------------------------------- 1 | import pkgutil 2 | import importlib 3 | 4 | 5 | def discover(): 6 | return { 7 | name: importlib.import_module(name) 8 | for _, name, _ in pkgutil.iter_modules() 9 | if name.startswith("turnkeyml_plugin_") 10 | } 11 | -------------------------------------------------------------------------------- /src/turnkeyml/sequence/__init__.py: -------------------------------------------------------------------------------- 1 | from .sequence import Sequence 2 | -------------------------------------------------------------------------------- /src/turnkeyml/tools/__init__.py: -------------------------------------------------------------------------------- 1 | from .tool import Tool, FirstTool, NiceHelpFormatter 2 | -------------------------------------------------------------------------------- /src/turnkeyml/tools/discovery/__init__.py: -------------------------------------------------------------------------------- 1 | from .discover import Discover 2 | -------------------------------------------------------------------------------- /src/turnkeyml/version.py: -------------------------------------------------------------------------------- 1 | __version__ = "6.2.5" 2 | -------------------------------------------------------------------------------- /test/helpers/check_slurm_output.sh: -------------------------------------------------------------------------------- 1 | # Checks whether a slurm output contains any errors 2 | SLURM_OUTPUT="$1" 3 | if ! grep -q "Successful build!" $SLURM_OUTPUT 4 | then 5 | cat $SLURM_OUTPUT 6 | echo "Model has not been successfully built" 7 | exit 1 8 | fi 9 | if grep -q "CommandNotFoundError" $SLURM_OUTPUT 10 | then 11 | cat $SLURM_OUTPUT 12 | echo "CommandNotFoundError fount in slurm output. This is likely due to conda not being found." 13 | exit 1 14 | fi 15 | --------------------------------------------------------------------------------