From 307e13174ce0b52cfc7ef2e2df57eea6912de3ae Mon Sep 17 00:00:00 2001
From: david <davidtnfsh@gmail.com>
Date: Tue, 8 Jan 2019 18:46:37 +0800
Subject: [PATCH 1/2] <chores>: add pipfile

---
 Pipfile      |  14 ++
 Pipfile.lock | 485 +++++++++++++++++++++++++++++++++++++++++++++++++++
 README.md    |   3 +
 3 files changed, 502 insertions(+)
 create mode 100644 Pipfile
 create mode 100644 Pipfile.lock

diff --git a/Pipfile b/Pipfile
new file mode 100644
index 0000000..dd15ab0
--- /dev/null
+++ b/Pipfile
@@ -0,0 +1,14 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+yapf = "*"
+tensorflow = "*"
+scikit-image = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.6"
diff --git a/Pipfile.lock b/Pipfile.lock
new file mode 100644
index 0000000..8b56eaa
--- /dev/null
+++ b/Pipfile.lock
@@ -0,0 +1,485 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "c429218bc4fbae8dc17993d56e0d6cda92272a1af64aafb6d6e6a771d585b247"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "3.6"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "absl-py": {
+            "hashes": [
+                "sha256:87519e3b91a3d573664c6e2ee33df582bb68dca6642ae3cf3a4361b1c0a4e9d6"
+            ],
+            "version": "==0.6.1"
+        },
+        "astor": {
+            "hashes": [
+                "sha256:95c30d87a6c2cf89aa628b87398466840f0ad8652f88eb173125a6df8533fb8d",
+                "sha256:fb503b9e2fdd05609fbf557b916b4a7824171203701660f0c55bbf5a7a68713e"
+            ],
+            "version": "==0.7.1"
+        },
+        "cloudpickle": {
+            "hashes": [
+                "sha256:f169a8523a40eb0a3452e1878aac31da6759409fbafa51dd50d89d4a6b42bcf1",
+                "sha256:fac8deaad55cd9e6cc11bb1d61c66da730f3f602ea8433698ef10ce664e520ec"
+            ],
+            "version": "==0.6.1"
+        },
+        "cycler": {
+            "hashes": [
+                "sha256:1d8a5ae1ff6c5cf9b93e8811e581232ad8920aeec647c37316ceac982b08cb2d",
+                "sha256:cd7b2d1018258d7247a71425e9f26463dfb444d411c39569972f4ce586b0c9d8"
+            ],
+            "version": "==0.10.0"
+        },
+        "dask": {
+            "extras": [
+                "array"
+            ],
+            "hashes": [
+                "sha256:8a2c151d5862627c71fdc725760d710b7c037ec57730f453f392b896febfd0d5",
+                "sha256:a1fa4a3b2d7ce4dd0c68db4b68dadf2c283ff54d98bd72c556fc462000449ff7"
+            ],
+            "version": "==1.0.0"
+        },
+        "decorator": {
+            "hashes": [
+                "sha256:2c51dff8ef3c447388fe5e4453d24a2bf128d3a4c32af3fabef1f01c6851ab82",
+                "sha256:c39efa13fbdeb4506c476c9b3babf6a718da943dab7811c206005a4a956c080c"
+            ],
+            "version": "==4.3.0"
+        },
+        "gast": {
+            "hashes": [
+                "sha256:15b7a4a16522eeb3344516b4b94024f84c6d96dca4540564978cb7422d7ebb53"
+            ],
+            "version": "==0.2.1.post0"
+        },
+        "grpcio": {
+            "hashes": [
+                "sha256:082bc981d6aabfdb26bfdeab63f5626df3d2c5ac3a9ae8533dfa5ce73432f4fe",
+                "sha256:0e8ff79b12b8b07198dd847974fc32a4ed8c0d52d5224fabb9d28bf4c2e3f4a9",
+                "sha256:11c8026a3d35e8b9ad6cda7bf4f5e51b9b82e7f29a590ad194f63957657fa808",
+                "sha256:145e82aec0a643d7569499b1aa0d5167c99d9d26a2b8c4e4b3f5cd51b99a8cdc",
+                "sha256:1a820ebf0c924cbfa299cb59e4bc9582a24abfec89d9a36c281d78fa941115ae",
+                "sha256:284bee4657c4dd7d48835128b31975e8b0ea3a2eeb084c5d46de215b31d1f8f5",
+                "sha256:2a8b6b569fd23f4d9f2c8201fd8995519dfbddc60ceeffa8bf5bea2a8e9cb72c",
+                "sha256:38b93080df498656aea1dbab632e32013c580c2d00bd8c30d0f1d2c9513b0469",
+                "sha256:4837ad8fdcf99df0e89214ba42001469cab807851f30481db41fd84fc9358ce7",
+                "sha256:5447336edd6fea8ab35eca34ff5289e369e22c375bc2ac8156a419fa467949ac",
+                "sha256:57705e31f76db45b51f3a98bcfd362c89d58e99f846337a25fed957b4d43ae4f",
+                "sha256:612e742c748df51c921a7eefd76195d76467e3cc00e084e089af5b111d8210b7",
+                "sha256:62c777f801aee22100d8ea5fa057020e37b65541a8000091879a8560b089da9d",
+                "sha256:8317d351ab1e80cf20676ef3d4929d3e760df10e6e5c289283c36c4c92ca61f7",
+                "sha256:8703efaf03396123426fdea08b369712df1248fa5fdfdbee3f87a410f52e9bac",
+                "sha256:8b72721e64becd4a3e9580f12dbdf618d41e80d3ae7585dc8a921dbf76c979bb",
+                "sha256:8bb7dbe20fe883ee22a6cb2c1317ea228b75a3ef60f3749584ee2634192e3452",
+                "sha256:9a7ed6160e6c14058b4676aac68a8bf268f171f4c371ff0a0c0ab81b90803f70",
+                "sha256:a46c34768f292fa0d97e929591e51ec20dc857321d83b198de1dad9c8183e8cb",
+                "sha256:a7f21a7b48fcd9f51029419b22a9bfea097973cca5d1529b8578f1d2919e6b23",
+                "sha256:adfee9c9099cae92c2a4948bc95cc2cc3185cdf59b371e056b8dd19ed434247e",
+                "sha256:b3bbeadc6b99e4a42bf23803f5e9b292f23f3e37cc7f75a9f5efbfa9b812abc1",
+                "sha256:b51d49d89758ea45841130c5c7be79c68612d8834bd600994b8a2672c59dc9b9",
+                "sha256:cbb95a586fdf3e795eba28b4acc75fdfdb59a14df62e747fe8bc4572ef37b647",
+                "sha256:cdea5595b30f027e6603887b71f343ca5b209da74b910fe04fc25e1dfe6df263",
+                "sha256:d64350156dc4b21914409e0c93ffeeb4ceba193716fb1ae570df699383c4cd63",
+                "sha256:e10bbef59706a90672b295c0f82dcb6329d829643b8dd7c3bd120f89a093d740",
+                "sha256:e68e6afbbae2cbfadaabd33ee40314963cd83500feff733c07edb172674a7f8b",
+                "sha256:f0c0e48c255a63fec78be2f240ff5a3bd4291b1f83976895f6ee0085362568d0",
+                "sha256:f7bb6617bae5e7333e66ec1e7aac1fe419b59e0e34a8717f97e1ce2791ab9d3a",
+                "sha256:fa6e14bce7ad5de2363abb644191489ddfffcdb2751337251f7ef962ab7e3293",
+                "sha256:fd6774bbb6c717f725b39394757445ead4f69c471118364933aadb81a4f16961"
+            ],
+            "version": "==1.17.1"
+        },
+        "h5py": {
+            "hashes": [
+                "sha256:05750b91640273c69989c657eaac34b091abdd75efc8c4824c82aaf898a2da0a",
+                "sha256:082a27208aa3a2286e7272e998e7e225b2a7d4b7821bd840aebf96d50977abbb",
+                "sha256:08e2e8297195f9e813e894b6c63f79372582787795bba2014a2db6a2de95f713",
+                "sha256:0dd2adeb2e9de5081eb8dcec88874e7fd35dae9a21557be3a55a3c7d491842a4",
+                "sha256:0f94de7a10562b991967a66bbe6dda9808e18088676834c0a4dcec3fdd3bcc6f",
+                "sha256:106e42e2e01e486a3d32eeb9ba0e3a7f65c12fa8998d63625fa41fb8bdc44cdb",
+                "sha256:1606c66015f04719c41a9863c156fc0e6b992150de21c067444bcb82e7d75579",
+                "sha256:1854c4beff9961e477e133143c5e5e355dac0b3ebf19c52cf7cc1b1ef757703c",
+                "sha256:1e9fb6f1746500ea91a00193ce2361803c70c6b13f10aae9a33ad7b5bd28e800",
+                "sha256:2cca17e80ddb151894333377675db90cd0279fa454776e0a4f74308376afd050",
+                "sha256:30e365e8408759db3778c361f1e4e0fe8e98a875185ae46c795a85e9bafb9cdf",
+                "sha256:3206bac900e16eda81687d787086f4ffd4f3854980d798e191a9868a6510c3ae",
+                "sha256:3c23d72058647cee19b30452acc7895621e2de0a0bd5b8a1e34204b9ea9ed43c",
+                "sha256:407b5f911a83daa285bbf1ef78a9909ee5957f257d3524b8606be37e8643c5f0",
+                "sha256:4162953714a9212d373ac953c10e3329f1e830d3c7473f2a2e4f25dd6241eef0",
+                "sha256:5fc7aba72a51b2c80605eba1c50dbf84224dcd206279d30a75c154e5652e1fe4",
+                "sha256:713ac19307e11de4d9833af0c4bd6778bde0a3d967cafd2f0f347223711c1e31",
+                "sha256:71b946d80ef3c3f12db157d7778b1fe74a517ca85e94809358b15580983c2ce2",
+                "sha256:8cc4aed71e20d87e0a6f02094d718a95252f11f8ed143bc112d22167f08d4040",
+                "sha256:9d41ca62daf36d6b6515ab8765e4c8c4388ee18e2a665701fef2b41563821002",
+                "sha256:a744e13b000f234cd5a5b2a1f95816b819027c57f385da54ad2b7da1adace2f3",
+                "sha256:b087ee01396c4b34e9dc41e3a6a0442158206d383c19c7d0396d52067b17c1cb",
+                "sha256:b0f03af381d33306ce67d18275b61acb4ca111ced645381387a02c8a5ee1b796",
+                "sha256:b9e4b8dfd587365bdd719ae178fa1b6c1231f81280b1375eef8626dfd8761bf3",
+                "sha256:c5dd4ec75985b99166c045909e10f0534704d102848b1d9f0992720e908928e7",
+                "sha256:d2b82f23cd862a9d05108fe99967e9edfa95c136f532a71cb3d28dc252771f50",
+                "sha256:e58a25764472af07b7e1c4b10b0179c8ea726446c7141076286e41891bf3a563",
+                "sha256:f3b49107fbfc77333fc2b1ef4d5de2abcd57e7ea3a1482455229494cf2da56ce"
+            ],
+            "version": "==2.9.0"
+        },
+        "keras-applications": {
+            "hashes": [
+                "sha256:721dda4fa4e043e5bbd6f52a2996885c4639a7130ae478059b3798d0706f5ae7",
+                "sha256:a03af60ddc9c5afdae4d5c9a8dd4ca857550e0b793733a5072e0725829b87017"
+            ],
+            "version": "==1.0.6"
+        },
+        "keras-preprocessing": {
+            "hashes": [
+                "sha256:90d04c1750bccceef88ac09475c291b4b5f6aa1eaf0603167061b1aa8b043c61",
+                "sha256:ef2e482c4336fcf7180244d06f4374939099daa3183816e82aee7755af35b754"
+            ],
+            "version": "==1.0.5"
+        },
+        "kiwisolver": {
+            "hashes": [
+                "sha256:0ee4ed8b3ae8f5f712b0aa9ebd2858b5b232f1b9a96b0943dceb34df2a223bc3",
+                "sha256:0f7f532f3c94e99545a29f4c3f05637f4d2713e7fd91b4dd8abfc18340b86cd5",
+                "sha256:1a078f5dd7e99317098f0e0d490257fd0349d79363e8c923d5bb76428f318421",
+                "sha256:1aa0b55a0eb1bd3fa82e704f44fb8f16e26702af1a073cc5030eea399e617b56",
+                "sha256:2874060b91e131ceeff00574b7c2140749c9355817a4ed498e82a4ffa308ecbc",
+                "sha256:379d97783ba8d2934d52221c833407f20ca287b36d949b4bba6c75274bcf6363",
+                "sha256:3b791ddf2aefc56382aadc26ea5b352e86a2921e4e85c31c1f770f527eb06ce4",
+                "sha256:4329008a167fac233e398e8a600d1b91539dc33c5a3eadee84c0d4b04d4494fa",
+                "sha256:45813e0873bbb679334a161b28cb9606d9665e70561fd6caa8863e279b5e464b",
+                "sha256:53a5b27e6b5717bdc0125338a822605084054c80f382051fb945d2c0e6899a20",
+                "sha256:574f24b9805cb1c72d02b9f7749aa0cc0b81aa82571be5201aa1453190390ae5",
+                "sha256:66f82819ff47fa67a11540da96966fb9245504b7f496034f534b81cacf333861",
+                "sha256:79e5fe3ccd5144ae80777e12973027bd2f4f5e3ae8eb286cabe787bed9780138",
+                "sha256:83410258eb886f3456714eea4d4304db3a1fc8624623fc3f38a487ab36c0f653",
+                "sha256:8b6a7b596ce1d2a6d93c3562f1178ebd3b7bb445b3b0dd33b09f9255e312a965",
+                "sha256:9576cb63897fbfa69df60f994082c3f4b8e6adb49cccb60efb2a80a208e6f996",
+                "sha256:95a25d9f3449046ecbe9065be8f8380c03c56081bc5d41fe0fb964aaa30b2195",
+                "sha256:a424f048bebc4476620e77f3e4d1f282920cef9bc376ba16d0b8fe97eec87cde",
+                "sha256:aaec1cfd94f4f3e9a25e144d5b0ed1eb8a9596ec36d7318a504d813412563a85",
+                "sha256:acb673eecbae089ea3be3dcf75bfe45fc8d4dcdc951e27d8691887963cf421c7",
+                "sha256:b15bc8d2c2848a4a7c04f76c9b3dc3561e95d4dabc6b4f24bfabe5fd81a0b14f",
+                "sha256:b1c240d565e977d80c0083404c01e4d59c5772c977fae2c483f100567f50847b",
+                "sha256:c595693de998461bcd49b8d20568c8870b3209b8ea323b2a7b0ea86d85864694",
+                "sha256:ce3be5d520b4d2c3e5eeb4cd2ef62b9b9ab8ac6b6fedbaa0e39cdb6f50644278",
+                "sha256:e0f910f84b35c36a3513b96d816e6442ae138862257ae18a0019d2fc67b041dc",
+                "sha256:ea36e19ac0a483eea239320aef0bd40702404ff8c7e42179a2d9d36c5afcb55c",
+                "sha256:efabbcd4f406b532206b8801058c8bab9e79645b9880329253ae3322b7b02cd5",
+                "sha256:f923406e6b32c86309261b8195e24e18b6a8801df0cfc7814ac44017bfcb3939"
+            ],
+            "version": "==1.0.1"
+        },
+        "markdown": {
+            "hashes": [
+                "sha256:c00429bd503a47ec88d5e30a751e147dcb4c6889663cd3e2ba0afe858e009baa",
+                "sha256:d02e0f9b04c500cde6637c11ad7c72671f359b87b9fe924b2383649d8841db7c"
+            ],
+            "version": "==3.0.1"
+        },
+        "matplotlib": {
+            "hashes": [
+                "sha256:16aa61846efddf91df623bbb4598e63be1068a6b6a2e6361cc802b41c7a286eb",
+                "sha256:1975b71a33ac986bb39b6d5cfbc15c7b1f218f1134efb4eb3881839d6ae69984",
+                "sha256:2b222744bd54781e6cc0b717fa35a54e5f176ba2ced337f27c5b435b334ef854",
+                "sha256:317643c0e88fad55414347216362b2e229c130edd5655fea5f8159a803098468",
+                "sha256:4269ce3d1b897d46fc3cc2273a0cc2a730345bb47e4456af662e6fca85c89dd7",
+                "sha256:65214fd668975077cdf8d408ccf2b2d6bdf73b4e6895a79f8e99ce4f0b43fcdb",
+                "sha256:74bc213ab8a92d86a0b304d9359d1e1d14168d4c6121b83862c9d8a88b89a738",
+                "sha256:88949be0db54755995dfb0210d0099a8712a3c696c860441971354c3debfc4af",
+                "sha256:8e1223d868be89423ec95ada5f37aa408ee64fe76ccb8e4d5f533699ba4c0e4a",
+                "sha256:9fa00f2d7a552a95fa6016e498fdeb6d74df537853dda79a9055c53dfc8b6e1a",
+                "sha256:c27fd46cab905097ba4bc28d5ba5289930f313fb1970c9d41092c9975b80e9b4",
+                "sha256:c94b792af431f6adb6859eb218137acd9a35f4f7442cea57e4a59c54751c36af",
+                "sha256:f4c12a01eb2dc16693887a874ba948b18c92f425c4d329639ece6d3bb8e631bb"
+            ],
+            "version": "==3.0.2"
+        },
+        "networkx": {
+            "hashes": [
+                "sha256:45e56f7ab6fe81652fb4bc9f44faddb0e9025f469f602df14e3b2551c2ea5c8b"
+            ],
+            "version": "==2.2"
+        },
+        "numpy": {
+            "hashes": [
+                "sha256:0df89ca13c25eaa1621a3f09af4c8ba20da849692dcae184cb55e80952c453fb",
+                "sha256:154c35f195fd3e1fad2569930ca51907057ae35e03938f89a8aedae91dd1b7c7",
+                "sha256:18e84323cdb8de3325e741a7a8dd4a82db74fde363dce32b625324c7b32aa6d7",
+                "sha256:1e8956c37fc138d65ded2d96ab3949bd49038cc6e8a4494b1515b0ba88c91565",
+                "sha256:23557bdbca3ccbde3abaa12a6e82299bc92d2b9139011f8c16ca1bb8c75d1e95",
+                "sha256:24fd645a5e5d224aa6e39d93e4a722fafa9160154f296fd5ef9580191c755053",
+                "sha256:36e36b6868e4440760d4b9b44587ea1dc1f06532858d10abba98e851e154ca70",
+                "sha256:3d734559db35aa3697dadcea492a423118c5c55d176da2f3be9c98d4803fc2a7",
+                "sha256:416a2070acf3a2b5d586f9a6507bb97e33574df5bd7508ea970bbf4fc563fa52",
+                "sha256:4a22dc3f5221a644dfe4a63bf990052cc674ef12a157b1056969079985c92816",
+                "sha256:4d8d3e5aa6087490912c14a3c10fbdd380b40b421c13920ff468163bc50e016f",
+                "sha256:4f41fd159fba1245e1958a99d349df49c616b133636e0cf668f169bce2aeac2d",
+                "sha256:561ef098c50f91fbac2cc9305b68c915e9eb915a74d9038ecf8af274d748f76f",
+                "sha256:56994e14b386b5c0a9b875a76d22d707b315fa037affc7819cda08b6d0489756",
+                "sha256:73a1f2a529604c50c262179fcca59c87a05ff4614fe8a15c186934d84d09d9a5",
+                "sha256:7da99445fd890206bfcc7419f79871ba8e73d9d9e6b82fe09980bc5bb4efc35f",
+                "sha256:99d59e0bcadac4aa3280616591fb7bcd560e2218f5e31d5223a2e12a1425d495",
+                "sha256:a4cc09489843c70b22e8373ca3dfa52b3fab778b57cf81462f1203b0852e95e3",
+                "sha256:a61dc29cfca9831a03442a21d4b5fd77e3067beca4b5f81f1a89a04a71cf93fa",
+                "sha256:b1853df739b32fa913cc59ad9137caa9cc3d97ff871e2bbd89c2a2a1d4a69451",
+                "sha256:b1f44c335532c0581b77491b7715a871d0dd72e97487ac0f57337ccf3ab3469b",
+                "sha256:b261e0cb0d6faa8fd6863af26d30351fd2ffdb15b82e51e81e96b9e9e2e7ba16",
+                "sha256:c857ae5dba375ea26a6228f98c195fec0898a0fd91bcf0e8a0cae6d9faf3eca7",
+                "sha256:cf5bb4a7d53a71bb6a0144d31df784a973b36d8687d615ef6a7e9b1809917a9b",
+                "sha256:db9814ff0457b46f2e1d494c1efa4111ca089e08c8b983635ebffb9c1573361f",
+                "sha256:df04f4bad8a359daa2ff74f8108ea051670cafbca533bb2636c58b16e962989e",
+                "sha256:ecf81720934a0e18526177e645cbd6a8a21bb0ddc887ff9738de07a1df5c6b61",
+                "sha256:edfa6fba9157e0e3be0f40168eb142511012683ac3dc82420bee4a3f3981b30e"
+            ],
+            "version": "==1.15.4"
+        },
+        "pillow": {
+            "hashes": [
+                "sha256:051de330a06c99d6f84bcf582960487835bcae3fc99365185dc2d4f65a390c0e",
+                "sha256:0ae5289948c5e0a16574750021bd8be921c27d4e3527800dc9c2c1d2abc81bf7",
+                "sha256:0b1efce03619cdbf8bcc61cfae81fcda59249a469f31c6735ea59badd4a6f58a",
+                "sha256:163136e09bd1d6c6c6026b0a662976e86c58b932b964f255ff384ecc8c3cefa3",
+                "sha256:18e912a6ccddf28defa196bd2021fe33600cbe5da1aa2f2e2c6df15f720b73d1",
+                "sha256:24ec3dea52339a610d34401d2d53d0fb3c7fd08e34b20c95d2ad3973193591f1",
+                "sha256:267f8e4c0a1d7e36e97c6a604f5b03ef58e2b81c1becb4fccecddcb37e063cc7",
+                "sha256:3273a28734175feebbe4d0a4cde04d4ed20f620b9b506d26f44379d3c72304e1",
+                "sha256:4c678e23006798fc8b6f4cef2eaad267d53ff4c1779bd1af8725cc11b72a63f3",
+                "sha256:4d4bc2e6bb6861103ea4655d6b6f67af8e5336e7216e20fff3e18ffa95d7a055",
+                "sha256:505738076350a337c1740a31646e1de09a164c62c07db3b996abdc0f9d2e50cf",
+                "sha256:5233664eadfa342c639b9b9977190d64ad7aca4edc51a966394d7e08e7f38a9f",
+                "sha256:5d95cb9f6cced2628f3e4de7e795e98b2659dfcc7176ab4a01a8b48c2c2f488f",
+                "sha256:7eda4c737637af74bac4b23aa82ea6fbb19002552be85f0b89bc27e3a762d239",
+                "sha256:801ddaa69659b36abf4694fed5aa9f61d1ecf2daaa6c92541bbbbb775d97b9fe",
+                "sha256:825aa6d222ce2c2b90d34a0ea31914e141a85edefc07e17342f1d2fdf121c07c",
+                "sha256:9c215442ff8249d41ff58700e91ef61d74f47dfd431a50253e1a1ca9436b0697",
+                "sha256:a3d90022f2202bbb14da991f26ca7a30b7e4c62bf0f8bf9825603b22d7e87494",
+                "sha256:a631fd36a9823638fe700d9225f9698fb59d049c942d322d4c09544dc2115356",
+                "sha256:a6523a23a205be0fe664b6b8747a5c86d55da960d9586db039eec9f5c269c0e6",
+                "sha256:a756ecf9f4b9b3ed49a680a649af45a8767ad038de39e6c030919c2f443eb000",
+                "sha256:b117287a5bdc81f1bac891187275ec7e829e961b8032c9e5ff38b70fd036c78f",
+                "sha256:ba04f57d1715ca5ff74bb7f8a818bf929a204b3b3c2c2826d1e1cc3b1c13398c",
+                "sha256:cd878195166723f30865e05d87cbaf9421614501a4bd48792c5ed28f90fd36ca",
+                "sha256:cee815cc62d136e96cf76771b9d3eb58e0777ec18ea50de5cfcede8a7c429aa8",
+                "sha256:d1722b7aa4b40cf93ac3c80d3edd48bf93b9208241d166a14ad8e7a20ee1d4f3",
+                "sha256:d7c1c06246b05529f9984435fc4fa5a545ea26606e7f450bdbe00c153f5aeaad",
+                "sha256:e9c8066249c040efdda84793a2a669076f92a301ceabe69202446abb4c5c5ef9",
+                "sha256:f227d7e574d050ff3996049e086e1f18c7bd2d067ef24131e50a1d3fe5831fbc",
+                "sha256:fc9a12aad714af36cf3ad0275a96a733526571e52710319855628f476dcb144e"
+            ],
+            "version": "==5.4.1"
+        },
+        "protobuf": {
+            "hashes": [
+                "sha256:10394a4d03af7060fa8a6e1cbf38cea44be1467053b0aea5bbfcb4b13c4b88c4",
+                "sha256:1489b376b0f364bcc6f89519718c057eb191d7ad6f1b395ffd93d1aa45587811",
+                "sha256:1931d8efce896981fe410c802fd66df14f9f429c32a72dd9cfeeac9815ec6444",
+                "sha256:196d3a80f93c537f27d2a19a4fafb826fb4c331b0b99110f985119391d170f96",
+                "sha256:46e34fdcc2b1f2620172d3a4885128705a4e658b9b62355ae5e98f9ea19f42c2",
+                "sha256:4b92e235a3afd42e7493b281c8b80c0c65cbef45de30f43d571d1ee40a1f77ef",
+                "sha256:574085a33ca0d2c67433e5f3e9a0965c487410d6cb3406c83bdaf549bfc2992e",
+                "sha256:59cd75ded98094d3cf2d79e84cdb38a46e33e7441b2826f3838dcc7c07f82995",
+                "sha256:5ee0522eed6680bb5bac5b6d738f7b0923b3cafce8c4b1a039a6107f0841d7ed",
+                "sha256:65917cfd5da9dfc993d5684643063318a2e875f798047911a9dd71ca066641c9",
+                "sha256:685bc4ec61a50f7360c9fd18e277b65db90105adbf9c79938bd315435e526b90",
+                "sha256:92e8418976e52201364a3174e40dc31f5fd8c147186d72380cbda54e0464ee19",
+                "sha256:9335f79d1940dfb9bcaf8ec881fb8ab47d7a2c721fb8b02949aab8bbf8b68625",
+                "sha256:a7ee3bb6de78185e5411487bef8bc1c59ebd97e47713cba3c460ef44e99b3db9",
+                "sha256:ceec283da2323e2431c49de58f80e1718986b79be59c266bb0509cbf90ca5b9e",
+                "sha256:fcfc907746ec22716f05ea96b7f41597dfe1a1c088f861efb8a0d4f4196a6f10"
+            ],
+            "version": "==3.6.1"
+        },
+        "pyparsing": {
+            "hashes": [
+                "sha256:40856e74d4987de5d01761a22d1621ae1c7f8774585acae358aa5c5936c6c90b",
+                "sha256:f353aab21fd474459d97b709e527b5571314ee5f067441dc9f88e33eecd96592"
+            ],
+            "version": "==2.3.0"
+        },
+        "python-dateutil": {
+            "hashes": [
+                "sha256:063df5763652e21de43de7d9e00ccf239f953a832941e37be541614732cdfc93",
+                "sha256:88f9287c0174266bb0d8cedd395cfba9c58e87e5ad86b2ce58859bc11be3cf02"
+            ],
+            "version": "==2.7.5"
+        },
+        "pywavelets": {
+            "hashes": [
+                "sha256:01683797c855d10d9ee78f46272b99b02f70a474e35baa54d150a385be9a9253",
+                "sha256:1096feae3ad08fa844978cbd1d8476cab34b5364b7f087f5878cd5b451001574",
+                "sha256:1732bd3638fae0693b7e30db63034f4f4ef36dc3018daf1da7ff024f060fc6e9",
+                "sha256:1a07231da072e3085b0c59cff6a2aa0ed3b17983f16d2b561764f5fa7207c8ac",
+                "sha256:25a98babb7907b4e6a5b508e519cd3179e6dc17c3840fb1b6306e82fdd4bcd3e",
+                "sha256:31417d6e5454881514974d40f7df40cc8588a3818b778137f2d51fd06f0ab7d9",
+                "sha256:351995c681d2a1ec556996bb645b8acdb0d2e4b80fb3617c1104a8d3cb048dfe",
+                "sha256:3c5cece36d4e17d395be6e9ac6b80ce7b774a1f71c251756c6163e63b6d878dc",
+                "sha256:4d739ee8d8b51098927709aac46ead2e965e397b6a5ac50047bd65a3d1a79ba6",
+                "sha256:4e4f993d2e3bc9c5eb6db8b3c70c94143831f32f56a9dd19bd35d85066bc5a37",
+                "sha256:64fd7615023e8cc043f084a61a562059ec0e14eb843a03662e9dbfb66deaae92",
+                "sha256:72b042ef5a21c0617eb8ba2ef524f107f3e5def3507105aad3d986c7b4544716",
+                "sha256:8b7be53059ac21a3b27d5e35be272c2b092b6348b336ad9c9c57f70697ab17a1",
+                "sha256:95a0a0ae8c4024a3c0658e496fd52a2baeefad2e521a4de132b668d2001e5a24",
+                "sha256:ae741e1919c08d1445362d2af4fb02ef3c611f2e3349ca0ba2a22fab494b86cc",
+                "sha256:b4428012419ada0c691240a388798a6c839477c5a968751ebfec663c0b4fe801",
+                "sha256:bc2f7ac5a3febf98e471dad4bc07e96a89bf954660d7d993d1d9486b0ce60aaa",
+                "sha256:c00e1b7903afa608b6eadf44da8d4d05ffeab99769965aed9e8fad85cd28e16c",
+                "sha256:c1473db14003eb544b08d94f3ac7bcebe8c839dc2d3dcdaf0db8c3a17b551674",
+                "sha256:d23f3fab4e3c81706517d99e1d3e0dcbce24009cf540a223b5d29baa7b781f4f",
+                "sha256:d27656cc329bf1b7ed64402de892bbee1d10b6cf0210a2d61d2f8a1c809e52a4",
+                "sha256:d7b0551df47ed6d2e7438d7c96339f2a8749e4687407a5bf0bb5a6eeb8ba8ffa",
+                "sha256:ee1e04e48f2160467c59fbf561eca8285d79573d2f98547c059bd05bcfd34321",
+                "sha256:f1d76e5c679f3668f6fcb4f6cfb31863ebcf86c742a64435264dc5d3a41f7ce0",
+                "sha256:f1eefc1220d754bd572fb409de844b9d2d5506c5dee5a72063343270146a8246",
+                "sha256:f7685816885e217acf90965dd55863152b0865d3b15cf7f2286b39aaf4bc4913"
+            ],
+            "version": "==1.0.1"
+        },
+        "scikit-image": {
+            "hashes": [
+                "sha256:29c6f82136bd9024b733052de1b61264a15b56d40f141753599a2bdcca865e7e",
+                "sha256:2dea14579d3c35f4f7827a43dc945c38620cc3d162f4937035ed29367b151663",
+                "sha256:3af0d129443e48c190be252072ee8aab56b77510d7c6c0098e285b8601bdfaf4",
+                "sha256:476f8ad8aa39b959bc55767e11734675612b10d15aef8a8a4ff4513b01c21132",
+                "sha256:4d94499d08ae8c1f54161d278a97c66a2cad6d2bece7ab8dc2cfc6ac84bf124b",
+                "sha256:51c9d506d2667d830e64fc69d37161321c1a628e785836d0f3da0bfdc78c71cc",
+                "sha256:585a082dba66b5f520549cf2957e53331b35071b7d7f31c7d589d12dd4381238",
+                "sha256:613a48ae6aca31ba1844c6a1fc10d53ac699c552931a264e343b01e020e7c506",
+                "sha256:651d04e00e34564943f868590bb9c3682d8f96b9c7dfc9c20ce96b3b8d149e51",
+                "sha256:702b88e7d3cc9367bac7e38ef3f21aa1ca01c512a4b33bb0678c89457bec937b",
+                "sha256:71122880441c4f611b760f3ab2887174b06f74deccbdf6eda1ee4c9cc7eca143",
+                "sha256:7794b63d9e205a965a0978b9f9f96de04c6b75fb94a768abdec77f67d3eaa223",
+                "sha256:77ac6718b0ce7b960cf0de0df2e2e5bbba624c25c2f0041c2dcb80bb3b8c482a",
+                "sha256:7999a51fa4110b6381f10789c6c4ef3d545ee35a333ccae83e6b69c0b40a0800",
+                "sha256:86a9b3b4f74f231e0a6bcfd3235dcf3f0118df25dac21201da5e064d681e2c50",
+                "sha256:90eac802ea1cc330644cb8a9d973be586a67286c7db82803bbed3772ae74ef17",
+                "sha256:9f847a7b8154876766751187a8fa84b382b079c5cd6408b031412a9bd3c1d79d",
+                "sha256:abac80ffcecd32350d2c3455d7dbd0bf316021ea4fe49ec0a904de71beeda1b0",
+                "sha256:af7051d8b517db3b2a4b997fb6d74c5a746a82bf60955ee9cf9973a77305464b",
+                "sha256:be2de17fee71c1b690b3bdba2747396353e6cacd4ae771e36f61a7e9cb143bb0",
+                "sha256:db73ca70a2ad5e0513eead02ce4eab0de595093c7240be00f1e95f1a6a78bc7f",
+                "sha256:e166278716c188bf256cb8f8ae136dab54c1675b54f24c725fc665e8c59417fa",
+                "sha256:f0f729ac91c63c8e5ad070c00b22c094af47345651428ab38fc3ffd2de0b325f",
+                "sha256:f864c526f1ebc1e13725c41488dc766d1f427f6f3d8c838b9c1d5474b30c796b",
+                "sha256:fdc663778a73587cb4b5fda4b9ceb22b4c47613d7164398f4da34b8030a1a73e",
+                "sha256:ff34ea2642d65da0b7049739dff12d8dd5930a8e8d835bd9927d6e62a37b05ea"
+            ],
+            "index": "pypi",
+            "version": "==0.14.1"
+        },
+        "scipy": {
+            "hashes": [
+                "sha256:02cb79ea38114dc480e9b08d6b87095728e8fb39b9a49b449ee443d678001611",
+                "sha256:03c827cdbc584e935264040b958e5fa0570a16095bee23a013482ba3f0e963a2",
+                "sha256:04f2b23258139c109d0524f111597dd095a505d9cb2c71e381d688d653877fa3",
+                "sha256:3132a9fab3f3545c8b0ba15688d11857efdd4a58d388d3785dc474f56fea7138",
+                "sha256:4b1f0883cb9d8ee963cf0a31c87341e9e758abb2cf1e5bcc0d7b066ef6b17573",
+                "sha256:4cce25c6e7ff7399c67dfe1b5423c36c391cf9b4b2be390c1675ab410f1ef503",
+                "sha256:51a2424c8ed80e60bdb9a896806e7adaf24a58253b326fbad10f80a6d06f2214",
+                "sha256:5706b785ca289fdfd91aa05066619e51d140613b613e35932601f2315f5d8470",
+                "sha256:58f0435f052cb60f1472c77f52a8f6642f8877b70559e5e0b9a1744f33f5cbe5",
+                "sha256:63e1d5ca9e5e1984f1a275276991b036e25d39d37dd7edbb3f4f6165c2da7dbb",
+                "sha256:64b2c35824da3ef6bb1e722216e4ef28802af6413c7586136500e343d34ba179",
+                "sha256:6f791987899532305126309578727c0197bddbafab9596bafe3e7bfab6e1ce13",
+                "sha256:72bd766f753fd32f072d30d7bc2ad492d56dbcbf3e13764e27635d5c41079339",
+                "sha256:7413080b381766a22d52814edb65631f0e323a7cea945c70021a672f38acc73f",
+                "sha256:78a67ee4845440e81cfbfabde20537ca12051d0eeac951fe4c6d8751feac3103",
+                "sha256:7994c044bf659b0a24ad7673ec7db85c2fadb87e4980a379a9fd5b086fe3649a",
+                "sha256:7dc4002f0a0a688774ef04878afe769ecd1ac21fe9b4b1d7125e2cf16170afd3",
+                "sha256:854bd87cc23824d5db4983956bc30f3790e1c7448f1a9e6a8fb7bff7601aef87",
+                "sha256:8608316d0cc01f8b25111c8adfe6efbc959cbba037a62c784551568d7ffbf280",
+                "sha256:8f5fcc87b48fc3dd6d901669c89af4feeb856dffb6f671539a238b7e8af1799c",
+                "sha256:937147086e8b4338bf139ca8fa98da650e3a46bf2ca617f8e9dd68c3971ec420",
+                "sha256:bc294841f6c822714af362095b181a853f47ed5ce757354bd2e4776d579ff3a4",
+                "sha256:bc6a88b0009a1b60eab5c22ac3a006f6968d6328de10c6a64ebb0d64a05548d3",
+                "sha256:c5eae911cf26b3c7eda889ec98d3c226f312c587acfaaf02602473f98b4c16d6",
+                "sha256:cca33a01a5987c650b87a1a910aa311ffa44e67cca1ff502ef9efdae5d9a8624",
+                "sha256:d1ae77b79fd5e27a10ba7c4e7c3a62927b9d29a4dccf28f6905c25d983aaf183",
+                "sha256:fb36064047e6bf87b6320a9b6eb7f525ef6863c7a4aef1a84a4bbfb043612617",
+                "sha256:fc1a19d95649439dbd50baca676bceb29bbfcd600aed2c5bd71d9bad82a87cfe"
+            ],
+            "version": "==1.2.0"
+        },
+        "six": {
+            "hashes": [
+                "sha256:3350809f0555b11f552448330d0b52d5f24c91a322ea4a15ef22629740f3761c",
+                "sha256:d16a0141ec1a18405cd4ce8b4613101da75da0e9a7aec5bdd4fa804d0e0eba73"
+            ],
+            "version": "==1.12.0"
+        },
+        "tensorboard": {
+            "hashes": [
+                "sha256:6f194519f41762bfdf5eb410ccf33226d1c252caf5ad8893288648bfbcf4d135",
+                "sha256:81170f66bf8f95c2e9f6b3fefe0ddc5472655a9e3793e73b5b5d4ec0ba395e76"
+            ],
+            "version": "==1.12.2"
+        },
+        "tensorflow": {
+            "hashes": [
+                "sha256:16fb8a59e724afd37a276d33b7e2ed070e5c84899a8d4cfc3fe1bb446a859da7",
+                "sha256:1ae50e44c0b29df5fb5b460118be5a257b4eb3e561008f64d2c4c715651259b7",
+                "sha256:1b7d09cc26ef727d628dcb74841b89374a38ed81af25bd589a21659ef67443da",
+                "sha256:2681b55d3e434e20fe98e3a3b1bde3588af62d7864b62feee4141a71e29ef594",
+                "sha256:42fc8398ce9f9895b488f516ea0143cf6cf2a3a5fc804da4a190b063304bc173",
+                "sha256:531619ad1c17b4084d09f442a9171318af813e81aae748e5de8274d561461749",
+                "sha256:5cee35f8a6a12e83560f30246811643efdc551c364bc981d27f21fbd0926403d",
+                "sha256:6ad6ed495f1a3d445c43d90cb2ce251ff5532fd6436e25f52977ee59ffa583df",
+                "sha256:cd8c1a899e3befe1ccb774ea1aae077a4b1286f855c956210b23766f4ac85c30",
+                "sha256:d3f3d7cd9bd4cdc7ebf25fd6c2dfc103dcf4b2834ae9276cc4cf897eb1515f6d",
+                "sha256:e4f479e6aca595acc98347364288cbdfd3c025ca85389380174ea75a43c327b7",
+                "sha256:f587dc03b5f0d1e50cca39b7159c9f21ffdec96273dbf5f7619d48c622cb21f2"
+            ],
+            "index": "pypi",
+            "version": "==1.12.0"
+        },
+        "termcolor": {
+            "hashes": [
+                "sha256:1d6d69ce66211143803fbc56652b41d73b4a400a2891d7bf7a1cdf4c02de613b"
+            ],
+            "version": "==1.1.0"
+        },
+        "toolz": {
+            "hashes": [
+                "sha256:929f0a7ea7f61c178bd951bdae93920515d3fbdbafc8e6caf82d752b9b3b31c9"
+            ],
+            "version": "==0.9.0"
+        },
+        "werkzeug": {
+            "hashes": [
+                "sha256:c3fd7a7d41976d9f44db327260e263132466836cef6f91512889ed60ad26557c",
+                "sha256:d5da73735293558eb1651ee2fddc4d0dedcfa06538b8813a2e20011583c9e49b"
+            ],
+            "version": "==0.14.1"
+        },
+        "wheel": {
+            "hashes": [
+                "sha256:029703bf514e16c8271c3821806a1c171220cc5bdd325cbf4e7da1e056a01db6",
+                "sha256:1e53cdb3f808d5ccd0df57f964263752aa74ea7359526d3da6c02114ec1e1d44"
+            ],
+            "markers": "python_version >= '3'",
+            "version": "==0.32.3"
+        },
+        "yapf": {
+            "hashes": [
+                "sha256:8aa7f9abdb97b4da4d3227306b88477982daafef0a96cc41639754ca31f46d55",
+                "sha256:f2df5891481f94ddadfbf8ae8ae499080752cfb06005a31bbb102f3012f8b944"
+            ],
+            "index": "pypi",
+            "version": "==0.25.0"
+        }
+    },
+    "develop": {}
+}
diff --git a/README.md b/README.md
index ff0c35f..b4fedf3 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,9 @@ The original caffe weights have been extracted using [Caffe to TensorFlow](https
 
 All code should be compatible with `Python 3.6` and `Tensorflow 1.x` (tested with 1.12). The model implementation can be found in `model.py`.
 
+1. `pip3 install -U pipenv`
+2. `pipenv install`
+
 ### Usage
 
 ```

From 24adddc69dbfcbc0dc26ca22a82437161d0e81d2 Mon Sep 17 00:00:00 2001
From: david <davidtnfsh@gmail.com>
Date: Tue, 8 Jan 2019 19:07:17 +0800
Subject: [PATCH 2/2] <style>: use yapf to format the code base

---
 classify_nsfw.py       |  54 +++++---
 eval/batch_classify.py |  79 ++++++-----
 eval/eval.py           |  16 ++-
 image_utils.py         |  61 +++++----
 model.py               | 298 ++++++++++++++++++++++++++++-------------
 5 files changed, 323 insertions(+), 185 deletions(-)

diff --git a/classify_nsfw.py b/classify_nsfw.py
index e5c4c7b..cd447fb 100644
--- a/classify_nsfw.py
+++ b/classify_nsfw.py
@@ -1,14 +1,13 @@
 #!/usr/bin/env python
-import sys
 import argparse
-import tensorflow as tf
-
-from model import OpenNsfwModel, InputType
-from image_utils import create_tensorflow_image_loader
-from image_utils import create_yahoo_image_loader
+import sys
 
 import numpy as np
 
+import tensorflow as tf
+from image_utils import (create_tensorflow_image_loader,
+                         create_yahoo_image_loader)
+from model import InputType, OpenNsfwModel
 
 IMAGE_LOADER_TENSORFLOW = "tensorflow"
 IMAGE_LOADER_YAHOO = "yahoo"
@@ -17,22 +16,33 @@
 def main(argv):
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("input_file", help="Path to the input image.\
+    parser.add_argument(
+        "input_file",
+        help="Path to the input image.\
                         Only jpeg images are supported.")
 
-    parser.add_argument("-m", "--model_weights", required=True,
-                        help="Path to trained model weights file")
-
-    parser.add_argument("-l", "--image_loader",
-                        default=IMAGE_LOADER_YAHOO,
-                        help="image loading mechanism",
-                        choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
-
-    parser.add_argument("-i", "--input_type",
-                        default=InputType.TENSOR.name.lower(),
-                        help="input type",
-                        choices=[InputType.TENSOR.name.lower(),
-                                 InputType.BASE64_JPEG.name.lower()])
+    parser.add_argument(
+        "-m",
+        "--model_weights",
+        required=True,
+        help="Path to trained model weights file")
+
+    parser.add_argument(
+        "-l",
+        "--image_loader",
+        default=IMAGE_LOADER_YAHOO,
+        help="image loading mechanism",
+        choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
+
+    parser.add_argument(
+        "-i",
+        "--input_type",
+        default=InputType.TENSOR.name.lower(),
+        help="input type",
+        choices=[
+            InputType.TENSOR.name.lower(),
+            InputType.BASE64_JPEG.name.lower()
+        ])
 
     args = parser.parse_args()
 
@@ -47,7 +57,8 @@ def main(argv):
 
         if input_type == InputType.TENSOR:
             if args.image_loader == IMAGE_LOADER_TENSORFLOW:
-                fn_load_image = create_tensorflow_image_loader(tf.Session(graph=tf.Graph()))
+                fn_load_image = create_tensorflow_image_loader(
+                    tf.Session(graph=tf.Graph()))
             else:
                 fn_load_image = create_yahoo_image_loader()
         elif input_type == InputType.BASE64_JPEG:
@@ -65,5 +76,6 @@ def main(argv):
         print("Results for '{}'".format(args.input_file))
         print("\tSFW score:\t{}\n\tNSFW score:\t{}".format(*predictions[0]))
 
+
 if __name__ == "__main__":
     main(sys.argv)
diff --git a/eval/batch_classify.py b/eval/batch_classify.py
index b768dda..29f38fb 100644
--- a/eval/batch_classify.py
+++ b/eval/batch_classify.py
@@ -1,20 +1,17 @@
-
+import argparse
+import glob
 import os
 import sys
 
-sys.path.append((os.path.normpath(
-                 os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                              '..'))))
-
-import argparse
-import glob
-import tensorflow as tf
 from tqdm import tqdm
 
-from model import OpenNsfwModel, InputType
-from image_utils import create_tensorflow_image_loader
-from image_utils import create_yahoo_image_loader
+import tensorflow as tf
+from image_utils import (create_tensorflow_image_loader,
+                         create_yahoo_image_loader)
+from model import InputType, OpenNsfwModel
 
+sys.path.append((os.path.normpath(
+    os.path.join(os.path.dirname(os.path.realpath(__file__)), '..'))))
 
 IMAGE_LOADER_TENSORFLOW = "tensorflow"
 IMAGE_LOADER_YAHOO = "yahoo"
@@ -25,37 +22,50 @@
 
 def create_batch_iterator(filenames, batch_size, fn_load_image):
     for i in range(0, len(filenames), batch_size):
-        yield list(map(fn_load_image, filenames[i:i+batch_size]))
+        yield list(map(fn_load_image, filenames[i:i + batch_size]))
 
 
 def create_tf_batch_iterator(filenames, batch_size):
     for i in range(0, len(filenames), batch_size):
         with tf.Session(graph=tf.Graph()) as session:
-            fn_load_image = create_tensorflow_image_loader(session,
-                                                           expand_dims=False)
+            fn_load_image = create_tensorflow_image_loader(
+                session, expand_dims=False)
 
-            yield list(map(fn_load_image, filenames[i:i+batch_size]))
+            yield list(map(fn_load_image, filenames[i:i + batch_size]))
 
 
 def main(argv):
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("-s", "--source", required=True,
-                        help="Folder containing the images to classify")
-
-    parser.add_argument("-o", "--output_file", required=True,
-                        help="Output file path")
-
-    parser.add_argument("-m", "--model_weights", required=True,
-                        help="Path to trained model weights file")
-
-    parser.add_argument("-b", "--batch_size", help="Number of images to \
-                        classify simultaneously.", type=int, default=64)
-
-    parser.add_argument("-l", "--image_loader",
-                        default=IMAGE_LOADER_YAHOO,
-                        help="image loading mechanism",
-                        choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
+    parser.add_argument(
+        "-s",
+        "--source",
+        required=True,
+        help="Folder containing the images to classify")
+
+    parser.add_argument(
+        "-o", "--output_file", required=True, help="Output file path")
+
+    parser.add_argument(
+        "-m",
+        "--model_weights",
+        required=True,
+        help="Path to trained model weights file")
+
+    parser.add_argument(
+        "-b",
+        "--batch_size",
+        help="Number of images to \
+                        classify simultaneously.",
+        type=int,
+        default=64)
+
+    parser.add_argument(
+        "-l",
+        "--image_loader",
+        default=IMAGE_LOADER_YAHOO,
+        help="image loading mechanism",
+        choices=[IMAGE_LOADER_YAHOO, IMAGE_LOADER_TENSORFLOW])
 
     args = parser.parse_args()
     batch_size = args.batch_size
@@ -85,8 +95,7 @@ def main(argv):
                                                fn_load_image)
 
     with tf.Session(graph=tf.Graph(), config=config) as session:
-        model.build(weights_path=args.model_weights,
-                    input_type=input_type)
+        model.build(weights_path=args.model_weights, input_type=input_type)
 
         session.run(tf.global_variables_initializer())
 
@@ -102,11 +111,11 @@ def main(argv):
                     fi = (batch_num * batch_size)
                     for i, prediction in enumerate(predictions):
                         filename = os.path.basename(filenames[fi + i])
-                        o.write('{}\t{}\t{}\n'.format(filename,
-                                                      prediction[0],
+                        o.write('{}\t{}\t{}\n'.format(filename, prediction[0],
                                                       prediction[1]))
 
                     progress_bar.update(len(images))
 
+
 if __name__ == "__main__":
     main(sys.argv)
diff --git a/eval/eval.py b/eval/eval.py
index 856d7a6..0d21388 100644
--- a/eval/eval.py
+++ b/eval/eval.py
@@ -1,7 +1,9 @@
-import sys
-import operator
 import argparse
+import operator
+import sys
+
 import numpy as np
+
 from scipy import stats
 
 
@@ -55,11 +57,12 @@ def test(first, second):
 def main(argv):
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("original",
-                        help="File containing base classifications")
+    parser.add_argument(
+        "original", help="File containing base classifications")
 
-    parser.add_argument("other",
-                        help="File containing classifications to compare to\
+    parser.add_argument(
+        "other",
+        help="File containing classifications to compare to\
                         base results")
 
     args = parser.parse_args()
@@ -86,5 +89,6 @@ def main(argv):
     print('NSFW:')
     print(test(original_classifications[:, 1], other_classifications[:, 1]))
 
+
 if __name__ == "__main__":
     main(sys.argv)
diff --git a/image_utils.py b/image_utils.py
index b4b77db..8f0835e 100644
--- a/image_utils.py
+++ b/image_utils.py
@@ -28,8 +28,8 @@ def load_image(image_path):
         imr.save(fh_im, format='JPEG')
         fh_im.seek(0)
 
-        image = (skimage.img_as_float(skimage.io.imread(fh_im, as_grey=False))
-                        .astype(np.float32))
+        image = (skimage.img_as_float(skimage.io.imread(
+            fh_im, as_grey=False)).astype(np.float32))
 
         H, W, _ = image.shape
         h, w = (224, 224)
@@ -39,7 +39,7 @@ def load_image(image_path):
         image = image[h_off:h_off + h, w_off:w_off + w, :]
 
         # RGB to BGR
-        image = image[:, :, :: -1]
+        image = image[:, :, ::-1]
 
         image = image.astype(np.float32, copy=False)
         image = image * 255.0
@@ -53,7 +53,8 @@ def load_image(image_path):
     return load_image
 
 
-def create_tensorflow_image_loader(session, expand_dims=True,
+def create_tensorflow_image_loader(session,
+                                   expand_dims=True,
                                    options=None,
                                    run_metadata=None):
     """Tensorflow image loader
@@ -76,13 +77,10 @@ def load_image(image_path):
 
         if expand_dims:
             image_batch = tf.expand_dims(image, axis=0)
-            return session.run(image_batch,
-                               options=options,
-                               run_metadata=run_metadata)
+            return session.run(
+                image_batch, options=options, run_metadata=run_metadata)
 
-        return session.run(image,
-                           options=options,
-                           run_metadata=run_metadata)
+        return session.run(image, options=options, run_metadata=run_metadata)
 
     return load_image
 
@@ -99,8 +97,8 @@ def decode_and_process(base64):
     # we have to do some preprocessing with map_fn, since functions like
     # decode_*, resize_images and crop_to_bounding_box do not support
     # processing of batches
-    image = tf.map_fn(decode_and_process, _input,
-                      back_prop=False, dtype=tf.float32)
+    image = tf.map_fn(
+        decode_and_process, _input, back_prop=False, dtype=tf.float32)
 
     return image
 
@@ -111,27 +109,34 @@ def __tf_jpeg_process(data):
     # The whole jpeg encode/decode dance is neccessary to generate a result
     # that matches the original model's (caffe) preprocessing
     # (as good as possible)
-    image = tf.image.decode_jpeg(data, channels=3,
-                                 fancy_upscaling=True,
-                                 dct_method="INTEGER_FAST")
+    image = tf.image.decode_jpeg(
+        data, channels=3, fancy_upscaling=True, dct_method="INTEGER_FAST")
 
     image = tf.image.convert_image_dtype(image, tf.float32, saturate=True)
-    image = tf.image.resize_images(image, (256, 256),
-                                   method=tf.image.ResizeMethod.BILINEAR,
-                                   align_corners=True)
+    image = tf.image.resize_images(
+        image, (256, 256),
+        method=tf.image.ResizeMethod.BILINEAR,
+        align_corners=True)
 
     image = tf.image.convert_image_dtype(image, tf.uint8, saturate=True)
 
-    image = tf.image.encode_jpeg(image, format='', quality=75,
-                                 progressive=False, optimize_size=False,
-                                 chroma_downsampling=True,
-                                 density_unit=None,
-                                 x_density=None, y_density=None,
-                                 xmp_metadata=None)
-
-    image = tf.image.decode_jpeg(image, channels=3,
-                                 fancy_upscaling=False,
-                                 dct_method="INTEGER_ACCURATE")
+    image = tf.image.encode_jpeg(
+        image,
+        format='',
+        quality=75,
+        progressive=False,
+        optimize_size=False,
+        chroma_downsampling=True,
+        density_unit=None,
+        x_density=None,
+        y_density=None,
+        xmp_metadata=None)
+
+    image = tf.image.decode_jpeg(
+        image,
+        channels=3,
+        fancy_upscaling=False,
+        dct_method="INTEGER_ACCURATE")
 
     image = tf.cast(image, dtype=tf.float32)
 
diff --git a/model.py b/model.py
index a03d9a1..b8d987e 100644
--- a/model.py
+++ b/model.py
@@ -1,7 +1,9 @@
 import math
+from enum import Enum, unique
+
 import numpy as np
+
 import tensorflow as tf
-from enum import Enum, unique
 
 
 @unique
@@ -24,21 +26,22 @@ def __init__(self):
         self.weights = {}
         self.bn_epsilon = 1e-5  # Default used by Caffe
 
-    def build(self, weights_path="open_nsfw-weights.npy",
+    def build(self,
+              weights_path="open_nsfw-weights.npy",
               input_type=InputType.TENSOR):
 
         self.weights = np.load(weights_path, encoding="latin1").item()
         self.input_tensor = None
 
         if input_type == InputType.TENSOR:
-            self.input = tf.placeholder(tf.float32,
-                                        shape=[None, 224, 224, 3],
-                                        name="input")
+            self.input = tf.placeholder(
+                tf.float32, shape=[None, 224, 224, 3], name="input")
             self.input_tensor = self.input
         elif input_type == InputType.BASE64_JPEG:
             from image_utils import load_base64_tensor
 
-            self.input = tf.placeholder(tf.string, shape=(None,), name="input")
+            self.input = tf.placeholder(
+                tf.string, shape=(None, ), name="input")
             self.input_tensor = load_base64_tensor(self.input)
         else:
             raise ValueError("invalid input type '{}'".format(input_type))
@@ -46,112 +49,193 @@ def build(self, weights_path="open_nsfw-weights.npy",
         x = self.input_tensor
 
         x = tf.pad(x, [[0, 0], [3, 3], [3, 3], [0, 0]], 'CONSTANT')
-        x = self.__conv2d("conv_1", x, filter_depth=64,
-                          kernel_size=7, stride=2, padding='valid')
+        x = self.__conv2d(
+            "conv_1",
+            x,
+            filter_depth=64,
+            kernel_size=7,
+            stride=2,
+            padding='valid')
 
         x = self.__batch_norm("bn_1", x)
         x = tf.nn.relu(x)
 
         x = tf.layers.max_pooling2d(x, pool_size=3, strides=2, padding='same')
 
-        x = self.__conv_block(stage=0, block=0, inputs=x,
-                              filter_depths=[32, 32, 128],
-                              kernel_size=3, stride=1)
-
-        x = self.__identity_block(stage=0, block=1, inputs=x,
-                                  filter_depths=[32, 32, 128], kernel_size=3)
-        x = self.__identity_block(stage=0, block=2, inputs=x,
-                                  filter_depths=[32, 32, 128], kernel_size=3)
-
-        x = self.__conv_block(stage=1, block=0, inputs=x,
-                              filter_depths=[64, 64, 256],
-                              kernel_size=3, stride=2)
-        x = self.__identity_block(stage=1, block=1, inputs=x,
-                                  filter_depths=[64, 64, 256], kernel_size=3)
-        x = self.__identity_block(stage=1, block=2, inputs=x,
-                                  filter_depths=[64, 64, 256], kernel_size=3)
-        x = self.__identity_block(stage=1, block=3, inputs=x,
-                                  filter_depths=[64, 64, 256], kernel_size=3)
-
-        x = self.__conv_block(stage=2, block=0, inputs=x,
-                              filter_depths=[128, 128, 512],
-                              kernel_size=3, stride=2)
-        x = self.__identity_block(stage=2, block=1, inputs=x,
-                                  filter_depths=[128, 128, 512], kernel_size=3)
-        x = self.__identity_block(stage=2, block=2, inputs=x,
-                                  filter_depths=[128, 128, 512], kernel_size=3)
-        x = self.__identity_block(stage=2, block=3, inputs=x,
-                                  filter_depths=[128, 128, 512], kernel_size=3)
-        x = self.__identity_block(stage=2, block=4, inputs=x,
-                                  filter_depths=[128, 128, 512], kernel_size=3)
-        x = self.__identity_block(stage=2, block=5, inputs=x,
-                                  filter_depths=[128, 128, 512], kernel_size=3)
-
-        x = self.__conv_block(stage=3, block=0, inputs=x,
-                              filter_depths=[256, 256, 1024], kernel_size=3,
-                              stride=2)
-        x = self.__identity_block(stage=3, block=1, inputs=x,
-                                  filter_depths=[256, 256, 1024],
-                                  kernel_size=3)
-        x = self.__identity_block(stage=3, block=2, inputs=x,
-                                  filter_depths=[256, 256, 1024],
-                                  kernel_size=3)
-
-        x = tf.layers.average_pooling2d(x, pool_size=7, strides=1,
-                                        padding="valid", name="pool")
+        x = self.__conv_block(
+            stage=0,
+            block=0,
+            inputs=x,
+            filter_depths=[32, 32, 128],
+            kernel_size=3,
+            stride=1)
+
+        x = self.__identity_block(
+            stage=0,
+            block=1,
+            inputs=x,
+            filter_depths=[32, 32, 128],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=0,
+            block=2,
+            inputs=x,
+            filter_depths=[32, 32, 128],
+            kernel_size=3)
+
+        x = self.__conv_block(
+            stage=1,
+            block=0,
+            inputs=x,
+            filter_depths=[64, 64, 256],
+            kernel_size=3,
+            stride=2)
+        x = self.__identity_block(
+            stage=1,
+            block=1,
+            inputs=x,
+            filter_depths=[64, 64, 256],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=1,
+            block=2,
+            inputs=x,
+            filter_depths=[64, 64, 256],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=1,
+            block=3,
+            inputs=x,
+            filter_depths=[64, 64, 256],
+            kernel_size=3)
+
+        x = self.__conv_block(
+            stage=2,
+            block=0,
+            inputs=x,
+            filter_depths=[128, 128, 512],
+            kernel_size=3,
+            stride=2)
+        x = self.__identity_block(
+            stage=2,
+            block=1,
+            inputs=x,
+            filter_depths=[128, 128, 512],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=2,
+            block=2,
+            inputs=x,
+            filter_depths=[128, 128, 512],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=2,
+            block=3,
+            inputs=x,
+            filter_depths=[128, 128, 512],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=2,
+            block=4,
+            inputs=x,
+            filter_depths=[128, 128, 512],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=2,
+            block=5,
+            inputs=x,
+            filter_depths=[128, 128, 512],
+            kernel_size=3)
+
+        x = self.__conv_block(
+            stage=3,
+            block=0,
+            inputs=x,
+            filter_depths=[256, 256, 1024],
+            kernel_size=3,
+            stride=2)
+        x = self.__identity_block(
+            stage=3,
+            block=1,
+            inputs=x,
+            filter_depths=[256, 256, 1024],
+            kernel_size=3)
+        x = self.__identity_block(
+            stage=3,
+            block=2,
+            inputs=x,
+            filter_depths=[256, 256, 1024],
+            kernel_size=3)
+
+        x = tf.layers.average_pooling2d(
+            x, pool_size=7, strides=1, padding="valid", name="pool")
 
         x = tf.reshape(x, shape=(-1, 1024))
 
-        self.logits = self.__fully_connected(name="fc_nsfw",
-                                             inputs=x, num_outputs=2)
+        self.logits = self.__fully_connected(
+            name="fc_nsfw", inputs=x, num_outputs=2)
         self.predictions = tf.nn.softmax(self.logits, name="predictions")
 
     """Get weights for layer with given name
     """
+
     def __get_weights(self, layer_name, field_name):
         if not layer_name in self.weights:
-            raise ValueError("No weights for layer named '{}' found"
-                             .format(layer_name))
+            raise ValueError(
+                "No weights for layer named '{}' found".format(layer_name))
 
         w = self.weights[layer_name]
         if not field_name in w:
-            raise (ValueError("No entry for field '{}' in layer named '{}'"
-                              .format(field_name, layer_name)))
+            raise (ValueError(
+                "No entry for field '{}' in layer named '{}'".format(
+                    field_name, layer_name)))
 
         return w[field_name]
 
     """Layer creation and weight initialization
     """
+
     def __fully_connected(self, name, inputs, num_outputs):
         return tf.layers.dense(
-            inputs=inputs, units=num_outputs, name=name,
+            inputs=inputs,
+            units=num_outputs,
+            name=name,
             kernel_initializer=tf.constant_initializer(
                 self.__get_weights(name, "weights"), dtype=tf.float32),
             bias_initializer=tf.constant_initializer(
                 self.__get_weights(name, "biases"), dtype=tf.float32))
 
-    def __conv2d(self, name, inputs, filter_depth, kernel_size, stride=1,
-                 padding="same", trainable=False):
+    def __conv2d(self,
+                 name,
+                 inputs,
+                 filter_depth,
+                 kernel_size,
+                 stride=1,
+                 padding="same",
+                 trainable=False):
 
         if padding.lower() == 'same' and kernel_size > 1:
             if kernel_size > 1:
                 oh = inputs.get_shape().as_list()[1]
                 h = inputs.get_shape().as_list()[1]
 
-                p = int(math.floor(((oh - 1) * stride + kernel_size - h)//2))
+                p = int(math.floor(((oh - 1) * stride + kernel_size - h) // 2))
 
-                inputs = tf.pad(inputs,
-                                [[0, 0], [p, p], [p, p], [0, 0]],
+                inputs = tf.pad(inputs, [[0, 0], [p, p], [p, p], [0, 0]],
                                 'CONSTANT')
             else:
-                raise Exception('unsupported kernel size for padding: "{}"'
-                                .format(kernel_size))
+                raise Exception('unsupported kernel size for padding: "{}"'.
+                                format(kernel_size))
 
         return tf.layers.conv2d(
-            inputs, filter_depth,
+            inputs,
+            filter_depth,
             kernel_size=(kernel_size, kernel_size),
-            strides=(stride, stride), padding='valid',
-            activation=None, trainable=trainable, name=name,
+            strides=(stride, stride),
+            padding='valid',
+            activation=None,
+            trainable=trainable,
+            name=name,
             kernel_initializer=tf.constant_initializer(
                 self.__get_weights(name, "weights"), dtype=tf.float32),
             bias_initializer=tf.constant_initializer(
@@ -159,7 +243,9 @@ def __conv2d(self, name, inputs, filter_depth, kernel_size, stride=1,
 
     def __batch_norm(self, name, inputs, training=False):
         return tf.layers.batch_normalization(
-            inputs, training=training, epsilon=self.bn_epsilon,
+            inputs,
+            training=training,
+            epsilon=self.bn_epsilon,
             gamma_initializer=tf.constant_initializer(
                 self.__get_weights(name, "scale"), dtype=tf.float32),
             beta_initializer=tf.constant_initializer(
@@ -172,8 +258,14 @@ def __batch_norm(self, name, inputs, training=False):
 
     """ResNet blocks
     """
-    def __conv_block(self, stage, block, inputs, filter_depths,
-                     kernel_size=3, stride=2):
+
+    def __conv_block(self,
+                     stage,
+                     block,
+                     inputs,
+                     filter_depths,
+                     kernel_size=3,
+                     stride=2):
         filter_depth1, filter_depth2, filter_depth3 = filter_depths
 
         conv_name_base = "conv_stage{}_block{}_branch".format(stage, block)
@@ -182,51 +274,63 @@ def __conv_block(self, stage, block, inputs, filter_depths,
                              .format(stage, block)
 
         shortcut = self.__conv2d(
-            name="conv{}".format(shortcut_name_post), stride=stride,
-            inputs=inputs, filter_depth=filter_depth3, kernel_size=1,
-            padding="same"
-        )
+            name="conv{}".format(shortcut_name_post),
+            stride=stride,
+            inputs=inputs,
+            filter_depth=filter_depth3,
+            kernel_size=1,
+            padding="same")
 
         shortcut = self.__batch_norm("bn{}".format(shortcut_name_post),
                                      shortcut)
 
         x = self.__conv2d(
             name="{}2a".format(conv_name_base),
-            inputs=inputs, filter_depth=filter_depth1, kernel_size=1,
-            stride=stride, padding="same",
+            inputs=inputs,
+            filter_depth=filter_depth1,
+            kernel_size=1,
+            stride=stride,
+            padding="same",
         )
         x = self.__batch_norm("{}2a".format(bn_name_base), x)
         x = tf.nn.relu(x)
 
         x = self.__conv2d(
             name="{}2b".format(conv_name_base),
-            inputs=x, filter_depth=filter_depth2, kernel_size=kernel_size,
-            padding="same", stride=1
-        )
+            inputs=x,
+            filter_depth=filter_depth2,
+            kernel_size=kernel_size,
+            padding="same",
+            stride=1)
         x = self.__batch_norm("{}2b".format(bn_name_base), x)
         x = tf.nn.relu(x)
 
         x = self.__conv2d(
             name="{}2c".format(conv_name_base),
-            inputs=x, filter_depth=filter_depth3, kernel_size=1,
-            padding="same", stride=1
-        )
+            inputs=x,
+            filter_depth=filter_depth3,
+            kernel_size=1,
+            padding="same",
+            stride=1)
         x = self.__batch_norm("{}2c".format(bn_name_base), x)
 
         x = tf.add(x, shortcut)
 
         return tf.nn.relu(x)
 
-    def __identity_block(self, stage, block, inputs,
-                         filter_depths, kernel_size):
+    def __identity_block(self, stage, block, inputs, filter_depths,
+                         kernel_size):
         filter_depth1, filter_depth2, filter_depth3 = filter_depths
         conv_name_base = "conv_stage{}_block{}_branch".format(stage, block)
         bn_name_base = "bn_stage{}_block{}_branch".format(stage, block)
 
         x = self.__conv2d(
             name="{}2a".format(conv_name_base),
-            inputs=inputs, filter_depth=filter_depth1, kernel_size=1,
-            stride=1, padding="same",
+            inputs=inputs,
+            filter_depth=filter_depth1,
+            kernel_size=1,
+            stride=1,
+            padding="same",
         )
 
         x = self.__batch_norm("{}2a".format(bn_name_base), x)
@@ -234,17 +338,21 @@ def __identity_block(self, stage, block, inputs,
 
         x = self.__conv2d(
             name="{}2b".format(conv_name_base),
-            inputs=x, filter_depth=filter_depth2, kernel_size=kernel_size,
-            padding="same", stride=1
-        )
+            inputs=x,
+            filter_depth=filter_depth2,
+            kernel_size=kernel_size,
+            padding="same",
+            stride=1)
         x = self.__batch_norm("{}2b".format(bn_name_base), x)
         x = tf.nn.relu(x)
 
         x = self.__conv2d(
             name="{}2c".format(conv_name_base),
-            inputs=x, filter_depth=filter_depth3, kernel_size=1,
-            padding="same", stride=1
-        )
+            inputs=x,
+            filter_depth=filter_depth3,
+            kernel_size=1,
+            padding="same",
+            stride=1)
         x = self.__batch_norm("{}2c".format(bn_name_base), x)
 
         x = tf.add(x, inputs)