diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00000.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00000.jpg new file mode 100644 index 0000000000000000000000000000000000000000..351bd0e3ca94877e4339feb179d8db8c01668713 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00000.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5bf59494ddc6a428d4a41bfd47361ef65163d938b5fd40551be7957e4004eb85 +size 236271 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00002.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00002.jpg new file mode 100644 index 0000000000000000000000000000000000000000..38376daca599acd4ab385868292041a9330d4279 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00002.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c968366fa93d24e9a4ab2880258eb400a3bb0e3066e3e64055441cea1d2d394a +size 231805 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00003.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00003.jpg new file mode 100644 index 0000000000000000000000000000000000000000..457175d7e0ab028af8d4aa075f0c6b235ad79a99 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00003.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:395860f62c38fb78ced34cfb1ea4d74cec773f1646561d42cf4b00f66b3bc7ae +size 293700 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00004.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00004.jpg new file mode 100644 index 0000000000000000000000000000000000000000..63cba4307fcd9447a32869e4c26493042bd0f3ba --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00004.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:098ed5da01195c22350e4d2b6b8fbdaa8e6dcc4aed011f47fc7a943d39b9eca4 +size 284712 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00005.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00005.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2d7195e7a7b4e249b5ee6161c6518bf04c4e265f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00005.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:615cae2023263457f11a8b8fd958fc4578a5cf3a682127e7c019e3c5e0bb7807 +size 254400 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00007.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00007.jpg new file mode 100644 index 0000000000000000000000000000000000000000..274214439376c69c9df2438276469e7bf16373fd --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00007.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:910826bd13635c078c780427c46882e1da269e0e9daeb93b0548097c3323317c +size 256135 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00008.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00008.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d1b920c314c9c7889ab43cde1873090a337ef215 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00008.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f3f6a2265dd9e68b1e6fff4f8a4aa52500cfaa727eb9d59c67a43eb5e7d10c8 +size 193285 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00009.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00009.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2a96be7cd953604d748cb6c746cf2b8f327c4f36 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00009.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7435a63d9e421dfa178768431b4ca29fbfd07998315f3080ce7e35edeae191d +size 271689 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00011.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00011.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c109f0945960767e19adeddfc386ca317f0391c2 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00011.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:06758f7a96ddac3d7727b0ba0fefab688e40fcbf0947a6223f4ef9d1b7eb6ffd +size 293265 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00013.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00013.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1d5e071a90bfd19d2ed96290144638c0762ec2dc --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00013.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db5bce14a38dfdde28ac20854a837cbe42168e0fb551137754a1a1eb46903ea7 +size 190964 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00018.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00018.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d1af0dbe24e36dc96ca63b886a439cc8e5a315cd --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00018.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e47930974538108623d0b943fa7fd1860777324521537a0f22485718fb504024 +size 179565 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00023.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00023.jpg new file mode 100644 index 0000000000000000000000000000000000000000..709bdb9c5b92ab538df1306910d1ea2390a8f50d --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00023.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:81d2f8ac78e355d3dbf5d97acaefec8f851e6792367e8b73ec2db8877839b021 +size 178223 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00025.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00025.jpg new file mode 100644 index 0000000000000000000000000000000000000000..815c84f673a0c4a86e1f5cdbcb17a712241fba22 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00025.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb0d32d85459423d94ddb8fffcd2962cbd3f830d40a6da64db9858f177ed9be3 +size 225414 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00027.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00027.jpg new file mode 100644 index 0000000000000000000000000000000000000000..301d91a65fe51c96cefb42b29b4881e2c57b6417 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00027.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8343a54eaae1961bff46d4e0f16fa6613a3729845bef7b0a70d1c21fe6e59934 +size 170885 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00029.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00029.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4f6bd16d55352c56b30d207dcbf35f784b2a041a --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00029.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c376595f9ca5be7d61967c9464dbe68e881abeeaafe9bdbf7a4e1781a535985 +size 206621 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00031.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00031.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b102802116287c0ea0019dcf670876ce10dccd04 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00031.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10ff63b1523616941bea94d1b895fc310a2a836957a2127ed1af3b4db2b0a880 +size 196083 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00038.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00038.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1e09593ba31198f8e140a72d3f79ba56057602c1 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00038.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa4d81999c1bef525015f366412614f46b82c8b094a32991b413d2c6fecf05cf +size 252983 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00040.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00040.jpg new file mode 100644 index 0000000000000000000000000000000000000000..07c03404a8050eb53174469881c7987a991253bf --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00040.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f5ce8598ad20c64fca4d2e17da6336c2a87d0a626f12f147215167ff329b8920 +size 170435 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00041.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00041.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b0409089b7245960c526eb897244dad6d0b2f5a7 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00041.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:80430601ae64d85768a59169b60778e69757e642a5dcf9afaa6c080adf8c9a3c +size 156191 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00043.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00043.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff6958e84f52065675da4f08569acaa61161049b --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00043.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9427a7f1beb8d578790701f774e5bbeb5f3ef73f9632d2d0592b3198242273c2 +size 187106 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00046.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00046.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f614af767b1c4aef9ad0dc89f2fff8370438e331 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00046.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c71dd6888dab4969e1a625be5f796573fb2af446e97f9bb1d9d1bf4b7ed593c +size 180557 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00047.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00047.jpg new file mode 100644 index 0000000000000000000000000000000000000000..265f5bed9fc5cd7f0d2043a84430ae5edafb0b3f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00047.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:206bd29f9bb7a70d8637cf17a5fbac91ef1775e176350185559937b705e7356c +size 232705 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00049.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00049.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9fe1ae01eaffc797c5743db185356eb6a8848d01 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00049.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8d9a7c4d083712883427a37522bc0ffa5571a0ffc6b096d6d999eba58553efd +size 250907 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00052.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00052.jpg new file mode 100644 index 0000000000000000000000000000000000000000..23a3c9d6465576aac7fdfcb6e8576033a100dc96 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00052.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab2955b9b2f4958e4976295790903c476a1d476d4c8a007b15393387555efd5f +size 175142 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00055.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00055.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a351e532ee9f657bc85c879f9a8912b6f9e4ad19 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00055.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a03f2aedacf3dc136b9d183006c53e2c4e07e564fd55b925500fffd979ca014f +size 244888 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00056.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00056.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b05d27d168dd20bfbaa8d63861652fc918c58208 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00056.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ccb1971ff93ceac34248f7c423aaba11c8ef9d5b0526cff5f38a2de41bc818a +size 205029 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00057.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00057.jpg new file mode 100644 index 0000000000000000000000000000000000000000..0062d40b9ecc41763ffe4338dacac44b11fcbe47 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00057.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a8c6da77d87f5572f429f9a015aa9d1d7540915c36a2aabc5024e2781b38f402 +size 174335 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00058.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00058.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a835df35178cab209e1a08ae04fb3427774d5dd4 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00058.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5566fd39a12bbabaec726da78e37dc557e802389d556b66c507c67eef5d0fcab +size 180906 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00059.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00059.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9ad3d3c5c358060e6d78354446afe4d2410c8991 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00059.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c274c9f81dc98579767135f44edbfea5349acadabbd16a454e4e3d70f2175cb +size 201730 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00060.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00060.jpg new file mode 100644 index 0000000000000000000000000000000000000000..61dc0aed73243dd98dfb2942b916c11ea27d2b07 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00060.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4390b75d1959ac095025281cfd30d36a099866ac27b355b80a3593091640c345 +size 225893 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00061.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00061.jpg new file mode 100644 index 0000000000000000000000000000000000000000..597f266398bc71bd6660789efc1ead61b9150722 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00061.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a351af7e20f769766211e646014cc9cbaf0f141cb1fba44290e95ef1f73b420b +size 254376 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00062.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00062.jpg new file mode 100644 index 0000000000000000000000000000000000000000..20225de92eddd0044a9c3391bea51777a87b02df --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00062.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98bceb2786a966ec9327d7861694086d9a638b30345f0a220baf94d696ba430d +size 172927 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00063.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00063.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fed25e0e7f183d181870f405a4a37c4ad873aa65 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00063.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49350430730b07e38e6b8b53ade1642513ae9139a413f146ff359edf43d68f9d +size 176159 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00064.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00064.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb4ecf2899a3935e0c3ffa665e1b3525bc7b6e85 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00064.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e50b8b8c4288ddd64aea53f34d3c0f15d7bf477f8d0369dff431d3d05f8b4ff +size 135968 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00066.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00066.jpg new file mode 100644 index 0000000000000000000000000000000000000000..56542c4705c1d599bd1d5360dc2ab77e91dced90 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00066.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:142bc10dd4fe4bbcf5e0c7ce59a790164b7936de357a759be3ff3e4ee29da9d7 +size 168909 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00067.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00067.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67a830bd1fb984dd771bd52d93de6f238293850f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00067.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:abacd69ff3fc6ea24ee1e66a7af3fdc4f7d44e65c53a3ffc0f84231c8e6fc7b9 +size 147325 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00068.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00068.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d9d1c06a1c9b21e20c6085a63509ebbaef5aaf7e --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00068.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4b9f1c8b85a31648da8c959717f020616b830fda0d082957b0a5efa9f29f0678 +size 165913 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00070.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00070.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c1cc9e051c894fea61294268173777ff136d26ff --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00070.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65ccdac234a640f10d763af26d272e3594c963fd856552b7acabfd7b51f9e91f +size 162064 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00071.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00071.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a4c0ab3f0e9f676c646d69c172a2352c8821dcf9 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00071.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:281757abb19c28779ed4d23d866b5c43805aab905efc5fea9cf0b93fac216502 +size 283382 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00072.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00072.jpg new file mode 100644 index 0000000000000000000000000000000000000000..77a19d9e43062f05b8a6519002b9265b66146370 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00072.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e96af0127aff087a0fd374c304064f1abf6d74a94f1fb05a5dd7723e11826125 +size 158926 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00073.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00073.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07efdbe60793a32be4fcaa3d51332296001769f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00073.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec134b2bf9dba54eab02c0e8d7f4f0f3b01cd863f64d4eb275590fae12e06499 +size 198267 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00074.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00074.jpg new file mode 100644 index 0000000000000000000000000000000000000000..09249ac4043afa261bb525739e86d4c51b18eb3f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00074.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:af79836790809965aa6520dc57f4f634e887ae7caadf17a97f0cbf1400bfae9a +size 190190 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00075.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00075.jpg new file mode 100644 index 0000000000000000000000000000000000000000..be3aae7982d22672f4e70fa129f2205240a35575 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00075.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd1c93e71f7ef73c5a5dc70cf7d810d52888392e723090506fce424629d2c439 +size 189819 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00076.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00076.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1dfa1738fff05585c22e5e48f8d50654fa73effe --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00076.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ac60d6a8b5b1e8c736de309422dde498ec13d46c2204dc2406a11299b8beaa4 +size 176084 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00077.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00077.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fca5f828b4744026354a02a7479e205e26acd0ea --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00077.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6810b8c285f1adf174154ce717ad5ec5b3990561768cb83f72b9014d30c678bb +size 185458 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00078.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00078.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c51cb78683e7c18a158bb28583e72b703506257b --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00078.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:88d780017c746d96fbbc987d475901a7e4ba664de7290382805f39e8ac5ea9c2 +size 220835 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00079.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00079.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b1e91127a1633c5fe15f69d8ee0f4e57c487d5d5 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00079.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2346f802d7306afc5ec4f7f4a90646769e696ed2b4d4a362a3a5933eeeb61c0f +size 193736 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00080.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00080.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7b03edba3ece857f79537c793ecb3a47ba7d1c0 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00080.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b53af19114154448e2fe79bf883c0a0da09dcc1729e6c7c5cbf2efe5d979089 +size 120589 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00081.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00081.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1c337186ad8c6a04a66423546c6b8b26a13ad5b1 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00081.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45771f7138419d0012b995e17238bb6d0af7e980999283a8c3da2cea4b93c202 +size 129841 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00082.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00082.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6d5c7562102a3ee50b7ad4a283a8c05c15937f1b --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00082.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b735a0c2d278ca57f2cfef5d6f2a05548f194db55657ee5686e390a251796202 +size 177830 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00083.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00083.jpg new file mode 100644 index 0000000000000000000000000000000000000000..4c69b5a85e23d7eac765a8cb98bf4229e8df29e6 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00083.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:95e90ebe1a2b5c066dc5ddb3c5a0a7395420e5ebcb8ac20e25621ca101111ed4 +size 166034 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00084.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00084.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f68f8c4568f1d2b7a7455a6b790afa778c160ef2 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00084.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:982387d4d77cb27131e40c30bec2e82c80a6c17908a7228b411461e81dbc136e +size 320864 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00085.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00085.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1413571d7e25d50bbb42b675ba2ca4f1c6ae2d47 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00085.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad0dd0cdbdad43d0087881b54bcc99fa84988372e8f170662c191ee03ec841a3 +size 223587 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00086.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00086.jpg new file mode 100644 index 0000000000000000000000000000000000000000..99c69a6604da9c74d901e15c1ab2e9f76a308b4c --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00086.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f5405cc1a4242bad7f62764eaa82a292fb6e358ca4e32dcc717abe32c1659fb9 +size 216257 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00087.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00087.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c7f6bfce29b4fe3a1c36fa3016dfdc93de62ee05 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00087.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4b9e446df5a3951578299317a6483c2e50aaf1dc34c9c61f9c3149a5cd07459a +size 180002 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00088.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00088.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b9d738c05618d8778713bd20f60a2ea3a7da6793 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00088.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:779f1cc70c32c4ef924314f6877e245ee50a89cf034675fef8e85c2ca0d02cf7 +size 205979 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00089.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00089.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a6442425a4c4a81b3056a49249089c976012d410 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00089.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99f77841323b08b095b826b87f4f85ea0eec704ca07bf75e88d349ebdf8412fc +size 149368 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00090.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00090.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d7b02dd9363b4bd1910f3ccbe0dcf83841c69862 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00090.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a695e994287e21aa6e1c092fd3608d97b5cd65b19b90c8043aac33a0e4c0e05a +size 219693 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00091.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00091.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6409ed244e2ec108881de1d0e4b4ed6336c0ee3b --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00091.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc7625bdb84bb5e74f0a31458ff5e4a8b544674dd954097d197ba47be80567c7 +size 186784 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00092.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00092.jpg new file mode 100644 index 0000000000000000000000000000000000000000..dce7861f2a6df5e3067fb626aec2fc924e9b9859 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00092.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:275f3156f82b05970fb00cb65e37a267086659afdc8c64f6722f184610b4a72c +size 179366 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00093.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00093.jpg new file mode 100644 index 0000000000000000000000000000000000000000..56e71bbfbdf4d65d1849c3ac60a762dfa5914bab --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00093.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0787439e31217f378cece9bf2b263fee31f5edd1e56e0ca936351ad369f1309d +size 148334 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00094.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00094.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9c443ee5e16749f788275a4f242944fc6e6b2665 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00094.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c08b47b348b31a73e0abaf86da1c9ac0063fd8f82e3f8fc5942904f35e3e25f9 +size 162498 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00095.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00095.jpg new file mode 100644 index 0000000000000000000000000000000000000000..de6d7754d65f957994cbef7bced9697783423e3e --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00095.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8639605b12da9acbf784ff45ddbe231f72863334b406631056e3a17821aa266 +size 180065 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00096.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00096.jpg new file mode 100644 index 0000000000000000000000000000000000000000..db43f2955175dd44222ef98cc9edf3c26c654689 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00096.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4cbfb88187bf0f28fcaeef95dd873505870b72eaa7f76f2ccc5912c5c72dab1 +size 158198 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00098.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00098.jpg new file mode 100644 index 0000000000000000000000000000000000000000..67d19851ad36e27cc8f445fafe20f871bb8b5cd4 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00098.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b54a717b223f4ba7f9ad4b1fe6589e57b114549d8ea76e0e0fab3022e678aaf5 +size 151222 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00100.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00100.jpg new file mode 100644 index 0000000000000000000000000000000000000000..91140dcee6fe25bbb2c8b1d441324890c868e007 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00100.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61af8aee1fdb5c0e48f81761c2184e89e98c692db7d44297ee1fe472353e8960 +size 218097 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00101.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00101.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ab20820832b18dc5535a2a7062b86ba084ea4194 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00101.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a5565851f7f73e39286c22e4106a632fceaa6d38ac462ea3668c4f8ddadbb1e +size 155966 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00102.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00102.jpg new file mode 100644 index 0000000000000000000000000000000000000000..76437dde64a8bba1dff1127321ce1f6eaefff705 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00102.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3261312152b7a980010e3e9d96a4eab0d639ab4e6bc571332e20e4600e3152a4 +size 173457 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00103.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00103.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c54f0a3bdffad61b033d7a95a6f02159459dffda --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00103.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c7c2c46f3c3353cadedf60e6f9631b22f95aeb29de7293a3839f95eb976f8596 +size 166345 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00105.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00105.jpg new file mode 100644 index 0000000000000000000000000000000000000000..b49575e52c246adb2dc5ef55ac6e54d0a2f2c3c8 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00105.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d7621708d1813159f6ce9aef3de58485d846017f2c1e417fbae0f6a0af6f0f8 +size 216926 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00109.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00109.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d074e62b430ac3cd12094cd26cce76e55b1ea6c7 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00109.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6489918dffc3569f00c4138b7cfbfee461c45fc4e0f6452ee301fb0222900f06 +size 194542 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00113.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00113.jpg new file mode 100644 index 0000000000000000000000000000000000000000..ff582a31436b5188bf71a4f3f0d686f25bd703f0 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00113.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a48c99b4908c7e4c4f1cdc0f343d4e685127876466d772f40d75f85a0905747f +size 234804 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00114.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00114.jpg new file mode 100644 index 0000000000000000000000000000000000000000..5568de7e67d78a11cb016d7b2711e3f014e5cb7f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00114.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:613f6cfd7babbe0089129a693ecaebc8ace05b97e8a2e1fb2b0bdc0440ec9758 +size 177809 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00115.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00115.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fb8350110956acff49ca6cf9f3113f89f36bbd2f --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00115.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e699c15fce1fa5e18d2875e0db74a783105f1a6918a9ddf6e37e397fd802bdcd +size 204024 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00120.jpg b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00120.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fbebf2c5bded7b39457b3af7877bdf459aec6464 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/Vintage_face_00120.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfba554658aff2497c495ab5912339f641611f0d1531c7452cb835b7967c3947 +size 246860 diff --git a/54347a3d-ecb1-4e06-ad17-3952ccbde90a/metadata.jsonl b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/metadata.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..7a8a9424b07502d02e8b584bd6655c20a64332f9 --- /dev/null +++ b/54347a3d-ecb1-4e06-ad17-3952ccbde90a/metadata.jsonl @@ -0,0 +1,75 @@ +{"file_name": "Vintage_face_00120.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00115.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00114.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00113.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00109.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00105.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00103.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00102.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00101.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00100.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00098.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00096.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00095.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00094.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00093.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00092.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00091.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00090.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00089.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00088.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00087.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00086.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00085.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00084.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00083.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00082.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00081.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00080.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00079.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00078.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00077.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00076.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00075.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00074.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00073.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00072.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00071.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00070.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00068.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00067.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00066.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00064.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00063.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00062.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00061.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00060.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00059.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00058.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00057.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00056.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00055.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00052.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00049.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00047.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00046.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00043.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00041.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00040.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00038.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00031.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00029.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00027.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00025.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00023.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00018.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00013.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00011.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00009.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00008.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00007.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00005.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00004.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00003.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00002.jpg", "prompt": "in the style of TOK"} +{"file_name": "Vintage_face_00000.jpg", "prompt": "in the style of TOK"} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..30d7f6ba99242b5e2dd1b7de9335ef58cdd06119 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,11 @@ +peft==0.7.1 +-huggingface_hub +torch +git+https://github.com/huggingface/diffusers@518171600d3eb82fc4f4c84b81dd7564b02728dc +transformers==4.36.2 +accelerate==0.25.0 +safetensors==0.4.1 +prodigyopt==1.0 +hf-transfer==0.1.4 +git+https://github.com/huggingface/datasets.git@3f149204a2a5948287adcade5e90707aa5207a92 +git+https://github.com/huggingface/huggingface_hub.git@8d052492fe0059c606c1a48d7a914b15b64a834d \ No newline at end of file diff --git a/script.py b/script.py new file mode 100644 index 0000000000000000000000000000000000000000..ba63b9233c4a69cb32fb75ebf6d614f6c567ba82 --- /dev/null +++ b/script.py @@ -0,0 +1,129 @@ +import sys +import subprocess +from safetensors.torch import load_file +from diffusers import AutoPipelineForText2Image +from datasets import load_dataset +from huggingface_hub.repocard import RepoCard +from huggingface_hub import HfApi +import torch +import re +import argparse +import os +import zipfile + +def do_preprocess(class_data_dir): + print("Unzipping dataset") + zip_file_path = f"{class_data_dir}/class_images.zip" + with zipfile.ZipFile(zip_file_path, 'r') as zip_ref: + zip_ref.extractall(class_data_dir) + os.remove(zip_file_path) + +def do_train(script_args): + # Pass all arguments to trainer.py + print("Starting training...") + result = subprocess.run(['python', 'trainer.py'] + script_args) + if result.returncode != 0: + raise Exception("Training failed.") + +def replace_output_dir(text, output_dir, replacement): + # Define a pattern that matches the output_dir followed by whitespace, '/', new line, or "'" + # Add system name from HF only in the correct spots + pattern = rf"{output_dir}(?=[\s/'\n])" + return re.sub(pattern, replacement, text) + +def do_inference(dataset_name, output_dir, num_tokens): + widget_content = [] + try: + print("Starting inference to generate example images...") + dataset = load_dataset(dataset_name) + pipe = AutoPipelineForText2Image.from_pretrained( + "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16 + ) + pipe = pipe.to("cuda") + pipe.load_lora_weights(f'{output_dir}/pytorch_lora_weights.safetensors') + + prompts = dataset["train"]["prompt"] + if(num_tokens > 0): + tokens_sequence = ''.join(f'' for i in range(num_tokens)) + tokens_list = [f'' for i in range(num_tokens)] + + state_dict = load_file(f"{output_dir}/{output_dir}_emb.safetensors") + pipe.load_textual_inversion(state_dict["clip_l"], token=tokens_list, text_encoder=pipe.text_encoder, tokenizer=pipe.tokenizer) + pipe.load_textual_inversion(state_dict["clip_g"], token=tokens_list, text_encoder=pipe.text_encoder_2, tokenizer=pipe.tokenizer_2) + + prompts = [prompt.replace("TOK", tokens_sequence) for prompt in prompts] + + for i, prompt in enumerate(prompts): + image = pipe(prompt, num_inference_steps=25, guidance_scale=7.5).images[0] + filename = f"image-{i}.png" + image.save(f"{output_dir}/{filename}") + card_dict = { + "text": prompt, + "output": { + "url": filename + } + } + widget_content.append(card_dict) + except Exception as e: + print("Something went wrong with generating images, specifically: ", e) + + try: + api = HfApi() + username = api.whoami()["name"] + repo_id = api.create_repo(f"{username}/{output_dir}", exist_ok=True, private=True).repo_id + + with open(f'{output_dir}/README.md', 'r') as file: + readme_content = file.read() + + + readme_content = replace_output_dir(readme_content, output_dir, f"{username}/{output_dir}") + + card = RepoCard(readme_content) + if widget_content: + card.data["widget"] = widget_content + card.save(f'{output_dir}/README.md') + + print("Starting upload...") + api.upload_folder( + folder_path=output_dir, + repo_id=f"{username}/{output_dir}", + repo_type="model", + ) + except Exception as e: + print("Something went wrong with uploading your model, specificaly: ", e) + else: + print("Upload finished!") + +import sys +import argparse + +def main(): + # Capture all arguments except the script name + script_args = sys.argv[1:] + + # Create the argument parser + parser = argparse.ArgumentParser() + parser.add_argument('--dataset_name', required=True) + parser.add_argument('--output_dir', required=True) + parser.add_argument('--num_new_tokens_per_abstraction', type=int, default=0) + parser.add_argument('--train_text_encoder_ti', action='store_true') + parser.add_argument('--class_data_dir', help="Name of the class images dataset") + + # Parse known arguments + args, _ = parser.parse_known_args(script_args) + + # Set num_tokens to 0 if '--train_text_encoder_ti' is not present + if not args.train_text_encoder_ti: + args.num_new_tokens_per_abstraction = 0 + + # Proceed with training and inference + if args.class_data_dir: + do_preprocess(args.class_data_dir) + print("Pre-processing finished!") + do_train(script_args) + print("Training finished!") + do_inference(args.dataset_name, args.output_dir, args.num_new_tokens_per_abstraction) + print("All finished!") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/trainer.py b/trainer.py new file mode 100644 index 0000000000000000000000000000000000000000..979a17927182f851077a0770145eff40ac901cdf --- /dev/null +++ b/trainer.py @@ -0,0 +1,2104 @@ +#!/usr/bin/env python +# coding=utf-8 +# Copyright 2023 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and + +import argparse +import gc +import hashlib +import itertools +import logging +import math +import os +import re +import shutil +import warnings +from pathlib import Path +from typing import List, Optional + +import numpy as np +import torch +import torch.nn.functional as F + +# imports of the TokenEmbeddingsHandler class +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import DistributedDataParallelKwargs, ProjectConfiguration, set_seed +from huggingface_hub import create_repo, upload_folder +from packaging import version +from peft import LoraConfig +from peft.utils import get_peft_model_state_dict +from PIL import Image +from PIL.ImageOps import exif_transpose +from safetensors.torch import load_file, save_file +from torch.utils.data import Dataset +from torchvision import transforms +from tqdm.auto import tqdm +from transformers import AutoTokenizer, PretrainedConfig + +import diffusers +from diffusers import ( + AutoencoderKL, + DDPMScheduler, + DPMSolverMultistepScheduler, + StableDiffusionXLPipeline, + UNet2DConditionModel, +) +from diffusers.loaders import LoraLoaderMixin +from diffusers.optimization import get_scheduler +from diffusers.training_utils import compute_snr +from diffusers.utils import ( + check_min_version, + convert_all_state_dict_to_peft, + convert_state_dict_to_diffusers, + convert_state_dict_to_kohya, + is_wandb_available, +) +from diffusers.utils.import_utils import is_xformers_available + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.25.0.dev0") + +logger = get_logger(__name__) + + +def save_model_card( + repo_id: str, + images=None, + base_model=str, + train_text_encoder=False, + train_text_encoder_ti=False, + token_abstraction_dict=None, + instance_prompt=str, + validation_prompt=str, + repo_folder=None, + vae_path=None, +): + img_str = "widget:\n" + for i, image in enumerate(images): + image.save(os.path.join(repo_folder, f"image_{i}.png")) + img_str += f""" + - text: '{validation_prompt if validation_prompt else ' ' }' + output: + url: + "image_{i}.png" + """ + if not images: + img_str += f""" + - text: '{instance_prompt}' + """ + embeddings_filename = f"{repo_folder}_emb" + instance_prompt_webui = re.sub(r"", "", re.sub(r"", embeddings_filename, instance_prompt, count=1)) + ti_keys = ", ".join(f'"{match}"' for match in re.findall(r"", instance_prompt)) + if instance_prompt_webui != embeddings_filename: + instance_prompt_sentence = f"For example, `{instance_prompt_webui}`" + else: + instance_prompt_sentence = "" + trigger_str = f"You should use {instance_prompt} to trigger the image generation." + diffusers_imports_pivotal = "" + diffusers_example_pivotal = "" + webui_example_pivotal = "" + if train_text_encoder_ti: + trigger_str = ( + "To trigger image generation of trained concept(or concepts) replace each concept identifier " + "in you prompt with the new inserted tokens:\n" + ) + diffusers_imports_pivotal = """from huggingface_hub import hf_hub_download +from safetensors.torch import load_file + """ + diffusers_example_pivotal = f"""embedding_path = hf_hub_download(repo_id='{repo_id}', filename='{embeddings_filename}.safetensors' repo_type="model") +state_dict = load_file(embedding_path) +pipeline.load_textual_inversion(state_dict["clip_l"], token=[{ti_keys}], text_encoder=pipeline.text_encoder, tokenizer=pipeline.tokenizer) +pipeline.load_textual_inversion(state_dict["clip_g"], token=[{ti_keys}], text_encoder=pipeline.text_encoder_2, tokenizer=pipeline.tokenizer_2) + """ + webui_example_pivotal = f"""- *Embeddings*: download **[`{embeddings_filename}.safetensors` here ๐Ÿ’พ](/{repo_id}/blob/main/{embeddings_filename}.safetensors)**. + - Place it on it on your `embeddings` folder + - Use it by adding `{embeddings_filename}` to your prompt. {instance_prompt_sentence} + (you need both the LoRA and the embeddings as they were trained together for this LoRA) + """ + if token_abstraction_dict: + for key, value in token_abstraction_dict.items(): + tokens = "".join(value) + trigger_str += f""" +to trigger concept `{key}` โ†’ use `{tokens}` in your prompt \n +""" + + yaml = f"""--- +tags: +- stable-diffusion-xl +- stable-diffusion-xl-diffusers +- text-to-image +- diffusers +- lora +- template:sd-lora +{img_str} +base_model: {base_model} +instance_prompt: {instance_prompt} +license: openrail++ +--- +""" + + model_card = f""" +# SDXL LoRA DreamBooth - {repo_id} + + + +## Model description + +### These are {repo_id} LoRA adaption weights for {base_model}. + +## Download model + +### Use it with UIs such as AUTOMATIC1111, Comfy UI, SD.Next, Invoke + +- **LoRA**: download **[`{repo_folder}.safetensors` here ๐Ÿ’พ](/{repo_id}/blob/main/{repo_folder}.safetensors)**. + - Place it on your `models/Lora` folder. + - On AUTOMATIC1111, load the LoRA by adding `` to your prompt. On ComfyUI just [load it as a regular LoRA](https://comfyanonymous.github.io/ComfyUI_examples/lora/). +{webui_example_pivotal} + +## Use it with the [๐Ÿงจ diffusers library](https://github.com/huggingface/diffusers) + +```py +from diffusers import AutoPipelineForText2Image +import torch +{diffusers_imports_pivotal} +pipeline = AutoPipelineForText2Image.from_pretrained('stabilityai/stable-diffusion-xl-base-1.0', torch_dtype=torch.float16).to('cuda') +pipeline.load_lora_weights('{repo_id}', weight_name='pytorch_lora_weights.safetensors') +{diffusers_example_pivotal} +image = pipeline('{validation_prompt if validation_prompt else instance_prompt}').images[0] +``` + +For more details, including weighting, merging and fusing LoRAs, check the [documentation on loading LoRAs in diffusers](https://huggingface.co/docs/diffusers/main/en/using-diffusers/loading_adapters) + +## Trigger words + +{trigger_str} + +## Details +All [Files & versions](/{repo_id}/tree/main). + +The weights were trained using [๐Ÿงจ diffusers Advanced Dreambooth Training Script](https://github.com/huggingface/diffusers/blob/main/examples/advanced_diffusion_training/train_dreambooth_lora_sdxl_advanced.py). + +LoRA for the text encoder was enabled. {train_text_encoder}. + +Pivotal tuning was enabled: {train_text_encoder_ti}. + +Special VAE used for training: {vae_path}. + +""" + with open(os.path.join(repo_folder, "README.md"), "w") as f: + f.write(yaml + model_card) + + +def import_model_class_from_model_name_or_path( + pretrained_model_name_or_path: str, revision: str, subfolder: str = "text_encoder" +): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, subfolder=subfolder, revision=revision + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "CLIPTextModelWithProjection": + from transformers import CLIPTextModelWithProjection + + return CLIPTextModelWithProjection + else: + raise ValueError(f"{model_class} is not supported.") + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--pretrained_vae_model_name_or_path", + type=str, + default=None, + help="Path to pretrained VAE model with better numerical stability. More details: https://github.com/huggingface/diffusers/pull/4038.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--variant", + type=str, + default=None, + help="Variant of the model files of the pretrained model identifier from huggingface.co/models, 'e.g.' fp16", + ) + parser.add_argument( + "--dataset_name", + type=str, + default=None, + help=( + "The name of the Dataset (from the HuggingFace hub) containing the training data of instance images (could be your own, possibly private," + " dataset). It can also be a path pointing to a local copy of a dataset in your filesystem," + " or to a folder containing files that ๐Ÿค— Datasets can understand.To load the custom captions, the training set directory needs to follow the structure of a " + "datasets ImageFolder, containing both the images and the corresponding caption for each image. see: " + "https://huggingface.co/docs/datasets/image_dataset for more information" + ), + ) + parser.add_argument( + "--dataset_config_name", + type=str, + default=None, + help="The config of the Dataset. In some cases, a dataset may have more than one configuration (for example " + "if it contains different subsets of data within, and you only wish to load a specific subset - in that case specify the desired configuration using --dataset_config_name. Leave as " + "None if there's only one config.", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default=None, + help="A path to local folder containing the training data of instance images. Specify this arg instead of " + "--dataset_name if you wish to train using a local folder without custom captions. If you wish to train with custom captions please specify " + "--dataset_name instead.", + ) + + parser.add_argument( + "--cache_dir", + type=str, + default=None, + help="The directory where the downloaded models and datasets will be stored.", + ) + + parser.add_argument( + "--image_column", + type=str, + default="image", + help="The column of the dataset containing the target image. By " + "default, the standard Image Dataset maps out 'file_name' " + "to 'image'.", + ) + parser.add_argument( + "--caption_column", + type=str, + default=None, + help="The column of the dataset containing the instance prompt for each image", + ) + + parser.add_argument("--repeats", type=int, default=1, help="How many times to repeat the training data.") + + parser.add_argument( + "--class_data_dir", + type=str, + default=None, + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default=None, + required=True, + help="The prompt with identifier specifying the instance, e.g. 'photo of a TOK dog', 'in the style of TOK'", + ) + parser.add_argument( + "--token_abstraction", + type=str, + default="TOK", + help="identifier specifying the instance(or instances) as used in instance_prompt, validation prompt, " + "captions - e.g. TOK. To use multiple identifiers, please specify them in a comma seperated string - e.g. " + "'TOK,TOK2,TOK3' etc.", + ) + + parser.add_argument( + "--num_new_tokens_per_abstraction", + type=int, + default=2, + help="number of new tokens inserted to the tokenizers per token_abstraction identifier when " + "--train_text_encoder_ti = True. By default, each --token_abstraction (e.g. TOK) is mapped to 2 new " + "tokens - ", + ) + + parser.add_argument( + "--class_prompt", + type=str, + default=None, + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--validation_prompt", + type=str, + default=None, + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_epochs", + type=int, + default=50, + help=( + "Run dreambooth validation every X epochs. Dreambooth validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`." + ), + ) + parser.add_argument( + "--with_prior_preservation", + default=False, + action="store_true", + help="Flag to add prior preservation loss.", + ) + parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.") + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="lora-dreambooth-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=1024, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--crops_coords_top_left_h", + type=int, + default=0, + help=("Coordinate for (the height) to be included in the crop coordinate embeddings needed by SDXL UNet."), + ) + parser.add_argument( + "--crops_coords_top_left_w", + type=int, + default=0, + help=("Coordinate for (the height) to be included in the crop coordinate embeddings needed by SDXL UNet."), + ) + parser.add_argument( + "--center_crop", + default=False, + action="store_true", + help=( + "Whether to center crop the input images to the resolution. If not set, the images will be randomly" + " cropped. The images will be resized to the resolution first before cropping." + ), + ) + parser.add_argument( + "--train_text_encoder", + action="store_true", + help="Whether to train the text encoder. If set, the text encoder should be float32 precision.", + ) + parser.add_argument( + "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument( + "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images." + ) + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=None, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final" + " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=("Max number of checkpoints to store."), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warmup period) to use.", + ) + + parser.add_argument( + "--text_encoder_lr", + type=float, + default=5e-6, + help="Text encoder learning rate to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + + parser.add_argument( + "--snr_gamma", + type=float, + default=None, + help="SNR weighting gamma to be used if rebalancing the loss. Recommended value is 5.0. " + "More details here: https://arxiv.org/abs/2303.09556.", + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--lr_num_cycles", + type=int, + default=1, + help="Number of hard resets of the lr in cosine_with_restarts scheduler.", + ) + parser.add_argument("--lr_power", type=float, default=1.0, help="Power factor of the polynomial scheduler.") + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + + parser.add_argument( + "--train_text_encoder_ti", + action="store_true", + help=("Whether to use textual inversion"), + ) + + parser.add_argument( + "--train_text_encoder_ti_frac", + type=float, + default=0.5, + help=("The percentage of epochs to perform textual inversion"), + ) + + parser.add_argument( + "--train_text_encoder_frac", + type=float, + default=1.0, + help=("The percentage of epochs to perform text encoder tuning"), + ) + + parser.add_argument( + "--optimizer", + type=str, + default="adamW", + help=('The optimizer type to use. Choose between ["AdamW", "prodigy"]'), + ) + + parser.add_argument( + "--use_8bit_adam", + action="store_true", + help="Whether or not to use 8-bit Adam from bitsandbytes. Ignored if optimizer is not set to AdamW", + ) + + parser.add_argument( + "--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam and Prodigy optimizers." + ) + parser.add_argument( + "--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam and Prodigy optimizers." + ) + parser.add_argument( + "--prodigy_beta3", + type=float, + default=None, + help="coefficients for computing the Prodidy stepsize using running averages. If set to None, " + "uses the value of square root of beta2. Ignored if optimizer is adamW", + ) + parser.add_argument("--prodigy_decouple", type=bool, default=True, help="Use AdamW style decoupled weight decay") + parser.add_argument("--adam_weight_decay", type=float, default=1e-04, help="Weight decay to use for unet params") + parser.add_argument( + "--adam_weight_decay_text_encoder", type=float, default=None, help="Weight decay to use for text_encoder" + ) + + parser.add_argument( + "--adam_epsilon", + type=float, + default=1e-08, + help="Epsilon value for the Adam optimizer and Prodigy optimizers.", + ) + + parser.add_argument( + "--prodigy_use_bias_correction", + type=bool, + default=True, + help="Turn on Adam's bias correction. True by default. Ignored if optimizer is adamW", + ) + parser.add_argument( + "--prodigy_safeguard_warmup", + type=bool, + default=True, + help="Remove lr from the denominator of D estimate to avoid issues during warm-up stage. True by default. " + "Ignored if optimizer is adamW", + ) + parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--prior_generation_precision", + type=str, + default=None, + choices=["no", "fp32", "fp16", "bf16"], + help=( + "Choose prior generation precision between fp32, fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to fp16 if a GPU is available else fp32." + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + parser.add_argument( + "--rank", + type=int, + default=4, + help=("The dimension of the LoRA update matrices."), + ) + parser.add_argument( + "--cache_latents", + action="store_true", + default=False, + help="Cache the VAE latents", + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + if args.dataset_name is None and args.instance_data_dir is None: + raise ValueError("Specify either `--dataset_name` or `--instance_data_dir`") + + if args.dataset_name is not None and args.instance_data_dir is not None: + raise ValueError("Specify only one of `--dataset_name` or `--instance_data_dir`") + + if args.train_text_encoder and args.train_text_encoder_ti: + raise ValueError( + "Specify only one of `--train_text_encoder` or `--train_text_encoder_ti. " + "For full LoRA text encoder training check --train_text_encoder, for textual " + "inversion training check `--train_text_encoder_ti`" + ) + + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + # logger is not available yet + if args.class_data_dir is not None: + warnings.warn("You need not use --class_data_dir without --with_prior_preservation.") + if args.class_prompt is not None: + warnings.warn("You need not use --class_prompt without --with_prior_preservation.") + + return args + + +# Taken from https://github.com/replicate/cog-sdxl/blob/main/dataset_and_utils.py +class TokenEmbeddingsHandler: + def __init__(self, text_encoders, tokenizers): + self.text_encoders = text_encoders + self.tokenizers = tokenizers + + self.train_ids: Optional[torch.Tensor] = None + self.inserting_toks: Optional[List[str]] = None + self.embeddings_settings = {} + + def initialize_new_tokens(self, inserting_toks: List[str]): + idx = 0 + for tokenizer, text_encoder in zip(self.tokenizers, self.text_encoders): + assert isinstance(inserting_toks, list), "inserting_toks should be a list of strings." + assert all( + isinstance(tok, str) for tok in inserting_toks + ), "All elements in inserting_toks should be strings." + + self.inserting_toks = inserting_toks + special_tokens_dict = {"additional_special_tokens": self.inserting_toks} + tokenizer.add_special_tokens(special_tokens_dict) + text_encoder.resize_token_embeddings(len(tokenizer)) + + self.train_ids = tokenizer.convert_tokens_to_ids(self.inserting_toks) + + # random initialization of new tokens + std_token_embedding = text_encoder.text_model.embeddings.token_embedding.weight.data.std() + + print(f"{idx} text encodedr's std_token_embedding: {std_token_embedding}") + + text_encoder.text_model.embeddings.token_embedding.weight.data[self.train_ids] = ( + torch.randn(len(self.train_ids), text_encoder.text_model.config.hidden_size) + .to(device=self.device) + .to(dtype=self.dtype) + * std_token_embedding + ) + self.embeddings_settings[ + f"original_embeddings_{idx}" + ] = text_encoder.text_model.embeddings.token_embedding.weight.data.clone() + self.embeddings_settings[f"std_token_embedding_{idx}"] = std_token_embedding + + inu = torch.ones((len(tokenizer),), dtype=torch.bool) + inu[self.train_ids] = False + + self.embeddings_settings[f"index_no_updates_{idx}"] = inu + + print(self.embeddings_settings[f"index_no_updates_{idx}"].shape) + + idx += 1 + + def save_embeddings(self, file_path: str): + assert self.train_ids is not None, "Initialize new tokens before saving embeddings." + tensors = {} + # text_encoder_0 - CLIP ViT-L/14, text_encoder_1 - CLIP ViT-G/14 + idx_to_text_encoder_name = {0: "clip_l", 1: "clip_g"} + for idx, text_encoder in enumerate(self.text_encoders): + assert text_encoder.text_model.embeddings.token_embedding.weight.data.shape[0] == len( + self.tokenizers[0] + ), "Tokenizers should be the same." + new_token_embeddings = text_encoder.text_model.embeddings.token_embedding.weight.data[self.train_ids] + + # New tokens for each text encoder are saved under "clip_l" (for text_encoder 0), "clip_g" (for + # text_encoder 1) to keep compatible with the ecosystem. + # Note: When loading with diffusers, any name can work - simply specify in inference + tensors[idx_to_text_encoder_name[idx]] = new_token_embeddings + # tensors[f"text_encoders_{idx}"] = new_token_embeddings + + save_file(tensors, file_path) + + @property + def dtype(self): + return self.text_encoders[0].dtype + + @property + def device(self): + return self.text_encoders[0].device + + @torch.no_grad() + def retract_embeddings(self): + for idx, text_encoder in enumerate(self.text_encoders): + index_no_updates = self.embeddings_settings[f"index_no_updates_{idx}"] + text_encoder.text_model.embeddings.token_embedding.weight.data[index_no_updates] = ( + self.embeddings_settings[f"original_embeddings_{idx}"][index_no_updates] + .to(device=text_encoder.device) + .to(dtype=text_encoder.dtype) + ) + + # for the parts that were updated, we need to normalize them + # to have the same std as before + std_token_embedding = self.embeddings_settings[f"std_token_embedding_{idx}"] + + index_updates = ~index_no_updates + new_embeddings = text_encoder.text_model.embeddings.token_embedding.weight.data[index_updates] + off_ratio = std_token_embedding / new_embeddings.std() + + new_embeddings = new_embeddings * (off_ratio**0.1) + text_encoder.text_model.embeddings.token_embedding.weight.data[index_updates] = new_embeddings + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + class_prompt, + dataset_name, + dataset_config_name, + cache_dir, + image_column, + caption_column, + train_text_encoder_ti, + class_data_root=None, + class_num=None, + token_abstraction_dict=None, # token mapping for textual inversion + size=1024, + repeats=1, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + + self.instance_prompt = instance_prompt + self.custom_instance_prompts = None + self.class_prompt = class_prompt + self.token_abstraction_dict = token_abstraction_dict + self.train_text_encoder_ti = train_text_encoder_ti + # if --dataset_name is provided or a metadata jsonl file is provided in the local --instance_data directory, + # we load the training data using load_dataset + if dataset_name is not None: + try: + from datasets import load_dataset + except ImportError: + raise ImportError( + "You are trying to load your data using the datasets library. If you wish to train using custom " + "captions please install the datasets library: `pip install datasets`. If you wish to load a " + "local folder containing images only, specify --instance_data_dir instead." + ) + # Downloading and loading a dataset from the hub. + # See more about loading custom images at + # https://huggingface.co/docs/datasets/v2.0.0/en/dataset_script + dataset = load_dataset( + dataset_name, + dataset_config_name, + cache_dir=cache_dir, + ) + # Preprocessing the datasets. + column_names = dataset["train"].column_names + + # 6. Get the column names for input/target. + if image_column is None: + image_column = column_names[0] + logger.info(f"image column defaulting to {image_column}") + else: + if image_column not in column_names: + raise ValueError( + f"`--image_column` value '{image_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + instance_images = dataset["train"][image_column] + + if caption_column is None: + logger.info( + "No caption column provided, defaulting to instance_prompt for all images. If your dataset " + "contains captions/prompts for the images, make sure to specify the " + "column as --caption_column" + ) + self.custom_instance_prompts = None + else: + if caption_column not in column_names: + raise ValueError( + f"`--caption_column` value '{caption_column}' not found in dataset columns. Dataset columns are: {', '.join(column_names)}" + ) + custom_instance_prompts = dataset["train"][caption_column] + # create final list of captions according to --repeats + self.custom_instance_prompts = [] + for caption in custom_instance_prompts: + self.custom_instance_prompts.extend(itertools.repeat(caption, repeats)) + else: + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + instance_images = [Image.open(path) for path in list(Path(instance_data_root).iterdir())] + self.custom_instance_prompts = None + + self.instance_images = [] + for img in instance_images: + self.instance_images.extend(itertools.repeat(img, repeats)) + self.num_instance_images = len(self.instance_images) + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + if class_num is not None: + self.num_class_images = min(len(self.class_images_path), class_num) + else: + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = self.instance_images[index % self.num_instance_images] + instance_image = exif_transpose(instance_image) + + if not instance_image.mode == "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + + if self.custom_instance_prompts: + caption = self.custom_instance_prompts[index % self.num_instance_images] + if caption: + if self.train_text_encoder_ti: + # replace instances of --token_abstraction in caption with the new tokens: "" etc. + for token_abs, token_replacement in self.token_abstraction_dict.items(): + caption = caption.replace(token_abs, "".join(token_replacement)) + example["instance_prompt"] = caption + else: + example["instance_prompt"] = self.instance_prompt + + else: # costum prompts were provided, but length does not match size of image dataset + example["instance_prompt"] = self.instance_prompt + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + class_image = exif_transpose(class_image) + + if not class_image.mode == "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt"] = self.class_prompt + + return example + + +def collate_fn(examples, with_prior_preservation=False): + pixel_values = [example["instance_images"] for example in examples] + prompts = [example["instance_prompt"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if with_prior_preservation: + pixel_values += [example["class_images"] for example in examples] + prompts += [example["class_prompt"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + batch = {"pixel_values": pixel_values, "prompts": prompts} + return batch + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple GPUs." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example + + +def tokenize_prompt(tokenizer, prompt, add_special_tokens=False): + text_inputs = tokenizer( + prompt, + padding="max_length", + max_length=tokenizer.model_max_length, + truncation=True, + add_special_tokens=add_special_tokens, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + return text_input_ids + + +# Adapted from pipelines.StableDiffusionXLPipeline.encode_prompt +def encode_prompt(text_encoders, tokenizers, prompt, text_input_ids_list=None): + prompt_embeds_list = [] + + for i, text_encoder in enumerate(text_encoders): + if tokenizers is not None: + tokenizer = tokenizers[i] + text_input_ids = tokenize_prompt(tokenizer, prompt) + else: + assert text_input_ids_list is not None + text_input_ids = text_input_ids_list[i] + + prompt_embeds = text_encoder( + text_input_ids.to(text_encoder.device), + output_hidden_states=True, + ) + + # We are only ALWAYS interested in the pooled output of the final text encoder + pooled_prompt_embeds = prompt_embeds[0] + prompt_embeds = prompt_embeds.hidden_states[-2] + bs_embed, seq_len, _ = prompt_embeds.shape + prompt_embeds = prompt_embeds.view(bs_embed, seq_len, -1) + prompt_embeds_list.append(prompt_embeds) + + prompt_embeds = torch.concat(prompt_embeds_list, dim=-1) + pooled_prompt_embeds = pooled_prompt_embeds.view(bs_embed, -1) + return prompt_embeds, pooled_prompt_embeds + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + kwargs = DistributedDataParallelKwargs(find_unused_parameters=True) + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_config=accelerator_project_config, + kwargs_handlers=[kwargs], + ) + + if args.report_to == "wandb": + if not is_wandb_available(): + raise ImportError("Make sure to install wandb if you want to use it for logging during training.") + import wandb + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + torch_dtype = torch.float16 if accelerator.device.type == "cuda" else torch.float32 + if args.prior_generation_precision == "fp32": + torch_dtype = torch.float32 + elif args.prior_generation_precision == "fp16": + torch_dtype = torch.float16 + elif args.prior_generation_precision == "bf16": + torch_dtype = torch.bfloat16 + pipeline = StableDiffusionXLPipeline.from_pretrained( + args.pretrained_model_name_or_path, + torch_dtype=torch_dtype, + revision=args.revision, + variant=args.variant, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + model_id = args.hub_model_id or Path(args.output_dir).name + repo_id = None + if args.push_to_hub: + repo_id = create_repo(repo_id=model_id, exist_ok=True, token=args.hub_token).repo_id + + # Load the tokenizers + tokenizer_one = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + variant=args.variant, + use_fast=False, + ) + tokenizer_two = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer_2", + revision=args.revision, + variant=args.variant, + use_fast=False, + ) + + # import correct text encoder classes + text_encoder_cls_one = import_model_class_from_model_name_or_path( + args.pretrained_model_name_or_path, args.revision + ) + text_encoder_cls_two = import_model_class_from_model_name_or_path( + args.pretrained_model_name_or_path, args.revision, subfolder="text_encoder_2" + ) + + # Load scheduler and models + noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + text_encoder_one = text_encoder_cls_one.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision, variant=args.variant + ) + text_encoder_two = text_encoder_cls_two.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder_2", revision=args.revision, variant=args.variant + ) + vae_path = ( + args.pretrained_model_name_or_path + if args.pretrained_vae_model_name_or_path is None + else args.pretrained_vae_model_name_or_path + ) + vae = AutoencoderKL.from_pretrained( + vae_path, + subfolder="vae" if args.pretrained_vae_model_name_or_path is None else None, + revision=args.revision, + variant=args.variant, + ) + vae_scaling_factor = vae.config.scaling_factor + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision, variant=args.variant + ) + + if args.train_text_encoder_ti: + # we parse the provided token identifier (or identifiers) into a list. s.t. - "TOK" -> ["TOK"], "TOK, + # TOK2" -> ["TOK", "TOK2"] etc. + token_abstraction_list = "".join(args.token_abstraction.split()).split(",") + logger.info(f"list of token identifiers: {token_abstraction_list}") + + token_abstraction_dict = {} + token_idx = 0 + for i, token in enumerate(token_abstraction_list): + token_abstraction_dict[token] = [ + f"" for j in range(args.num_new_tokens_per_abstraction) + ] + token_idx += args.num_new_tokens_per_abstraction - 1 + + # replace instances of --token_abstraction in --instance_prompt with the new tokens: "" etc. + for token_abs, token_replacement in token_abstraction_dict.items(): + args.instance_prompt = args.instance_prompt.replace(token_abs, "".join(token_replacement)) + if args.with_prior_preservation: + args.class_prompt = args.class_prompt.replace(token_abs, "".join(token_replacement)) + + # initialize the new tokens for textual inversion + embedding_handler = TokenEmbeddingsHandler( + [text_encoder_one, text_encoder_two], [tokenizer_one, tokenizer_two] + ) + inserting_toks = [] + for new_tok in token_abstraction_dict.values(): + inserting_toks.extend(new_tok) + embedding_handler.initialize_new_tokens(inserting_toks=inserting_toks) + + # We only train the additional adapter LoRA layers + vae.requires_grad_(False) + text_encoder_one.requires_grad_(False) + text_encoder_two.requires_grad_(False) + unet.requires_grad_(False) + + # For mixed precision training we cast all non-trainable weights (vae, non-lora text_encoder and non-lora unet) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move unet, vae and text_encoder to device and cast to weight_dtype + unet.to(accelerator.device, dtype=weight_dtype) + + # The VAE is always in float32 to avoid NaN losses. + vae.to(accelerator.device, dtype=torch.float32) + + text_encoder_one.to(accelerator.device, dtype=weight_dtype) + text_encoder_two.to(accelerator.device, dtype=weight_dtype) + + if args.enable_xformers_memory_efficient_attention: + if is_xformers_available(): + import xformers + + xformers_version = version.parse(xformers.__version__) + if xformers_version == version.parse("0.0.16"): + logger.warn( + "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, " + "please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details." + ) + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.gradient_checkpointing: + unet.enable_gradient_checkpointing() + if args.train_text_encoder: + text_encoder_one.gradient_checkpointing_enable() + text_encoder_two.gradient_checkpointing_enable() + + # now we will add new LoRA weights to the attention layers + unet_lora_config = LoraConfig( + r=args.rank, + lora_alpha=args.rank, + init_lora_weights="gaussian", + target_modules=["to_k", "to_q", "to_v", "to_out.0"], + ) + unet.add_adapter(unet_lora_config) + + # The text encoder comes from ๐Ÿค— transformers, so we cannot directly modify it. + # So, instead, we monkey-patch the forward calls of its attention-blocks. + if args.train_text_encoder: + text_lora_config = LoraConfig( + r=args.rank, + lora_alpha=args.rank, + init_lora_weights="gaussian", + target_modules=["q_proj", "k_proj", "v_proj", "out_proj"], + ) + text_encoder_one.add_adapter(text_lora_config) + text_encoder_two.add_adapter(text_lora_config) + + # if we use textual inversion, we freeze all parameters except for the token embeddings + # in text encoder + elif args.train_text_encoder_ti: + text_lora_parameters_one = [] + for name, param in text_encoder_one.named_parameters(): + if "token_embedding" in name: + # ensure that dtype is float32, even if rest of the model that isn't trained is loaded in fp16 + param = param.to(dtype=torch.float32) + param.requires_grad = True + text_lora_parameters_one.append(param) + else: + param.requires_grad = False + text_lora_parameters_two = [] + for name, param in text_encoder_two.named_parameters(): + if "token_embedding" in name: + # ensure that dtype is float32, even if rest of the model that isn't trained is loaded in fp16 + param = param.to(dtype=torch.float32) + param.requires_grad = True + text_lora_parameters_two.append(param) + else: + param.requires_grad = False + + # Make sure the trainable params are in float32. + if args.mixed_precision == "fp16": + models = [unet] + if args.train_text_encoder: + models.extend([text_encoder_one, text_encoder_two]) + for model in models: + for param in model.parameters(): + # only upcast trainable parameters (LoRA) into fp32 + if param.requires_grad: + param.data = param.to(torch.float32) + + # create custom saving & loading hooks so that `accelerator.save_state(...)` serializes in a nice format + def save_model_hook(models, weights, output_dir): + if accelerator.is_main_process: + # there are only two options here. Either are just the unet attn processor layers + # or there are the unet and text encoder atten layers + unet_lora_layers_to_save = None + text_encoder_one_lora_layers_to_save = None + text_encoder_two_lora_layers_to_save = None + + for model in models: + if isinstance(model, type(accelerator.unwrap_model(unet))): + unet_lora_layers_to_save = convert_state_dict_to_diffusers(get_peft_model_state_dict(model)) + elif isinstance(model, type(accelerator.unwrap_model(text_encoder_one))): + if args.train_text_encoder: + text_encoder_one_lora_layers_to_save = convert_state_dict_to_diffusers( + get_peft_model_state_dict(model) + ) + elif isinstance(model, type(accelerator.unwrap_model(text_encoder_two))): + if args.train_text_encoder: + text_encoder_two_lora_layers_to_save = convert_state_dict_to_diffusers( + get_peft_model_state_dict(model) + ) + else: + raise ValueError(f"unexpected save model: {model.__class__}") + + # make sure to pop weight so that corresponding model is not saved again + weights.pop() + + StableDiffusionXLPipeline.save_lora_weights( + output_dir, + unet_lora_layers=unet_lora_layers_to_save, + text_encoder_lora_layers=text_encoder_one_lora_layers_to_save, + text_encoder_2_lora_layers=text_encoder_two_lora_layers_to_save, + ) + if args.train_text_encoder_ti: + embedding_handler.save_embeddings(f"{output_dir}/{args.output_dir}_emb.safetensors") + + def load_model_hook(models, input_dir): + unet_ = None + text_encoder_one_ = None + text_encoder_two_ = None + + while len(models) > 0: + model = models.pop() + + if isinstance(model, type(accelerator.unwrap_model(unet))): + unet_ = model + elif isinstance(model, type(accelerator.unwrap_model(text_encoder_one))): + text_encoder_one_ = model + elif isinstance(model, type(accelerator.unwrap_model(text_encoder_two))): + text_encoder_two_ = model + else: + raise ValueError(f"unexpected save model: {model.__class__}") + + lora_state_dict, network_alphas = LoraLoaderMixin.lora_state_dict(input_dir) + LoraLoaderMixin.load_lora_into_unet(lora_state_dict, network_alphas=network_alphas, unet=unet_) + + text_encoder_state_dict = {k: v for k, v in lora_state_dict.items() if "text_encoder." in k} + LoraLoaderMixin.load_lora_into_text_encoder( + text_encoder_state_dict, network_alphas=network_alphas, text_encoder=text_encoder_one_ + ) + + text_encoder_2_state_dict = {k: v for k, v in lora_state_dict.items() if "text_encoder_2." in k} + LoraLoaderMixin.load_lora_into_text_encoder( + text_encoder_2_state_dict, network_alphas=network_alphas, text_encoder=text_encoder_two_ + ) + + accelerator.register_save_state_pre_hook(save_model_hook) + accelerator.register_load_state_pre_hook(load_model_hook) + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + unet_lora_parameters = list(filter(lambda p: p.requires_grad, unet.parameters())) + + if args.train_text_encoder: + text_lora_parameters_one = list(filter(lambda p: p.requires_grad, text_encoder_one.parameters())) + text_lora_parameters_two = list(filter(lambda p: p.requires_grad, text_encoder_two.parameters())) + + # If neither --train_text_encoder nor --train_text_encoder_ti, text_encoders remain frozen during training + freeze_text_encoder = not (args.train_text_encoder or args.train_text_encoder_ti) + + # Optimization parameters + unet_lora_parameters_with_lr = {"params": unet_lora_parameters, "lr": args.learning_rate} + if not freeze_text_encoder: + # different learning rate for text encoder and unet + text_lora_parameters_one_with_lr = { + "params": text_lora_parameters_one, + "weight_decay": args.adam_weight_decay_text_encoder + if args.adam_weight_decay_text_encoder + else args.adam_weight_decay, + "lr": args.text_encoder_lr if args.text_encoder_lr else args.learning_rate, + } + text_lora_parameters_two_with_lr = { + "params": text_lora_parameters_two, + "weight_decay": args.adam_weight_decay_text_encoder + if args.adam_weight_decay_text_encoder + else args.adam_weight_decay, + "lr": args.text_encoder_lr if args.text_encoder_lr else args.learning_rate, + } + params_to_optimize = [ + unet_lora_parameters_with_lr, + text_lora_parameters_one_with_lr, + text_lora_parameters_two_with_lr, + ] + else: + params_to_optimize = [unet_lora_parameters_with_lr] + + # Optimizer creation + if not (args.optimizer.lower() == "prodigy" or args.optimizer.lower() == "adamw"): + logger.warn( + f"Unsupported choice of optimizer: {args.optimizer}.Supported optimizers include [adamW, prodigy]." + "Defaulting to adamW" + ) + args.optimizer = "adamw" + + if args.use_8bit_adam and not args.optimizer.lower() == "adamw": + logger.warn( + f"use_8bit_adam is ignored when optimizer is not set to 'AdamW'. Optimizer was " + f"set to {args.optimizer.lower()}" + ) + + if args.optimizer.lower() == "adamw": + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + optimizer = optimizer_class( + params_to_optimize, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + if args.optimizer.lower() == "prodigy": + try: + import prodigyopt + except ImportError: + raise ImportError("To use Prodigy, please install the prodigyopt library: `pip install prodigyopt`") + + optimizer_class = prodigyopt.Prodigy + + if args.learning_rate <= 0.1: + logger.warn( + "Learning rate is too low. When using prodigy, it's generally better to set learning rate around 1.0" + ) + if args.train_text_encoder and args.text_encoder_lr: + logger.warn( + f"Learning rates were provided both for the unet and the text encoder- e.g. text_encoder_lr:" + f" {args.text_encoder_lr} and learning_rate: {args.learning_rate}. " + f"When using prodigy only learning_rate is used as the initial learning rate." + ) + # changes the learning rate of text_encoder_parameters_one and text_encoder_parameters_two to be + # --learning_rate + params_to_optimize[1]["lr"] = args.learning_rate + params_to_optimize[2]["lr"] = args.learning_rate + + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + beta3=args.prodigy_beta3, + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + decouple=args.prodigy_decouple, + use_bias_correction=args.prodigy_use_bias_correction, + safeguard_warmup=args.prodigy_safeguard_warmup, + ) + + # Dataset and DataLoaders creation: + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_prompt=args.class_prompt, + dataset_name=args.dataset_name, + dataset_config_name=args.dataset_config_name, + cache_dir=args.cache_dir, + image_column=args.image_column, + train_text_encoder_ti=args.train_text_encoder_ti, + caption_column=args.caption_column, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + token_abstraction_dict=token_abstraction_dict if args.train_text_encoder_ti else None, + class_num=args.num_class_images, + size=args.resolution, + repeats=args.repeats, + center_crop=args.center_crop, + ) + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation), + num_workers=args.dataloader_num_workers, + ) + + # Computes additional embeddings/ids required by the SDXL UNet. + # regular text embeddings (when `train_text_encoder` is not True) + # pooled text embeddings + # time ids + + def compute_time_ids(): + # Adapted from pipeline.StableDiffusionXLPipeline._get_add_time_ids + original_size = (args.resolution, args.resolution) + target_size = (args.resolution, args.resolution) + crops_coords_top_left = (args.crops_coords_top_left_h, args.crops_coords_top_left_w) + add_time_ids = list(original_size + crops_coords_top_left + target_size) + add_time_ids = torch.tensor([add_time_ids]) + add_time_ids = add_time_ids.to(accelerator.device, dtype=weight_dtype) + return add_time_ids + + if not args.train_text_encoder: + tokenizers = [tokenizer_one, tokenizer_two] + text_encoders = [text_encoder_one, text_encoder_two] + + def compute_text_embeddings(prompt, text_encoders, tokenizers): + with torch.no_grad(): + prompt_embeds, pooled_prompt_embeds = encode_prompt(text_encoders, tokenizers, prompt) + prompt_embeds = prompt_embeds.to(accelerator.device) + pooled_prompt_embeds = pooled_prompt_embeds.to(accelerator.device) + return prompt_embeds, pooled_prompt_embeds + + # Handle instance prompt. + instance_time_ids = compute_time_ids() + + # If no type of tuning is done on the text_encoder and custom instance prompts are NOT + # provided (i.e. the --instance_prompt is used for all images), we encode the instance prompt once to avoid + # the redundant encoding. + if freeze_text_encoder and not train_dataset.custom_instance_prompts: + instance_prompt_hidden_states, instance_pooled_prompt_embeds = compute_text_embeddings( + args.instance_prompt, text_encoders, tokenizers + ) + + # Handle class prompt for prior-preservation. + if args.with_prior_preservation: + class_time_ids = compute_time_ids() + if freeze_text_encoder: + class_prompt_hidden_states, class_pooled_prompt_embeds = compute_text_embeddings( + args.class_prompt, text_encoders, tokenizers + ) + + # Clear the memory here + if freeze_text_encoder and not train_dataset.custom_instance_prompts: + del tokenizers, text_encoders + gc.collect() + torch.cuda.empty_cache() + + # If custom instance prompts are NOT provided (i.e. the instance prompt is used for all images), + # pack the statically computed variables appropriately here. This is so that we don't + # have to pass them to the dataloader. + add_time_ids = instance_time_ids + if args.with_prior_preservation: + add_time_ids = torch.cat([add_time_ids, class_time_ids], dim=0) + + # if --train_text_encoder_ti we need add_special_tokens to be True fo textual inversion + add_special_tokens = True if args.train_text_encoder_ti else False + + if not train_dataset.custom_instance_prompts: + if freeze_text_encoder: + prompt_embeds = instance_prompt_hidden_states + unet_add_text_embeds = instance_pooled_prompt_embeds + if args.with_prior_preservation: + prompt_embeds = torch.cat([prompt_embeds, class_prompt_hidden_states], dim=0) + unet_add_text_embeds = torch.cat([unet_add_text_embeds, class_pooled_prompt_embeds], dim=0) + # if we're optmizing the text encoder (both if instance prompt is used for all images or custom prompts) we need to tokenize and encode the + # batch prompts on all training steps + else: + tokens_one = tokenize_prompt(tokenizer_one, args.instance_prompt, add_special_tokens) + tokens_two = tokenize_prompt(tokenizer_two, args.instance_prompt, add_special_tokens) + if args.with_prior_preservation: + class_tokens_one = tokenize_prompt(tokenizer_one, args.class_prompt, add_special_tokens) + class_tokens_two = tokenize_prompt(tokenizer_two, args.class_prompt, add_special_tokens) + tokens_one = torch.cat([tokens_one, class_tokens_one], dim=0) + tokens_two = torch.cat([tokens_two, class_tokens_two], dim=0) + + if args.train_text_encoder_ti and args.validation_prompt: + # replace instances of --token_abstraction in validation prompt with the new tokens: "" etc. + for token_abs, token_replacement in train_dataset.token_abstraction_dict.items(): + args.validation_prompt = args.validation_prompt.replace(token_abs, "".join(token_replacement)) + print("validation prompt:", args.validation_prompt) + + if args.cache_latents: + latents_cache = [] + for batch in tqdm(train_dataloader, desc="Caching latents"): + with torch.no_grad(): + batch["pixel_values"] = batch["pixel_values"].to( + accelerator.device, non_blocking=True, dtype=torch.float32 + ) + latents_cache.append(vae.encode(batch["pixel_values"]).latent_dist) + + if args.validation_prompt is None: + del vae + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes, + num_training_steps=args.max_train_steps * accelerator.num_processes, + num_cycles=args.lr_num_cycles, + power=args.lr_power, + ) + + # Prepare everything with our `accelerator`. + if not freeze_text_encoder: + unet, text_encoder_one, text_encoder_two, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, text_encoder_one, text_encoder_two, optimizer, train_dataloader, lr_scheduler + ) + else: + unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, optimizer, train_dataloader, lr_scheduler + ) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers("dreambooth-lora-sd-xl", config=vars(args)) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num batches each epoch = {len(train_dataloader)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the mos recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + + if path is None: + accelerator.print( + f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run." + ) + args.resume_from_checkpoint = None + initial_global_step = 0 + else: + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + initial_global_step = global_step + first_epoch = global_step // num_update_steps_per_epoch + + else: + initial_global_step = 0 + + progress_bar = tqdm( + range(0, args.max_train_steps), + initial=initial_global_step, + desc="Steps", + # Only show the progress bar once on each machine. + disable=not accelerator.is_local_main_process, + ) + + if args.train_text_encoder: + num_train_epochs_text_encoder = int(args.train_text_encoder_frac * args.num_train_epochs) + elif args.train_text_encoder_ti: # args.train_text_encoder_ti + num_train_epochs_text_encoder = int(args.train_text_encoder_ti_frac * args.num_train_epochs) + + for epoch in range(first_epoch, args.num_train_epochs): + # if performing any kind of optimization of text_encoder params + if args.train_text_encoder or args.train_text_encoder_ti: + if epoch == num_train_epochs_text_encoder: + print("PIVOT HALFWAY", epoch) + # stopping optimization of text_encoder params + # re setting the optimizer to optimize only on unet params + optimizer.param_groups[1]["lr"] = 0.0 + optimizer.param_groups[2]["lr"] = 0.0 + + else: + # still optimizng the text encoder + text_encoder_one.train() + text_encoder_two.train() + # set top parameter requires_grad = True for gradient checkpointing works + if args.train_text_encoder: + text_encoder_one.text_model.embeddings.requires_grad_(True) + text_encoder_two.text_model.embeddings.requires_grad_(True) + + unet.train() + for step, batch in enumerate(train_dataloader): + with accelerator.accumulate(unet): + prompts = batch["prompts"] + # encode batch prompts when custom prompts are provided for each image - + if train_dataset.custom_instance_prompts: + if freeze_text_encoder: + prompt_embeds, unet_add_text_embeds = compute_text_embeddings( + prompts, text_encoders, tokenizers + ) + + else: + tokens_one = tokenize_prompt(tokenizer_one, prompts, add_special_tokens) + tokens_two = tokenize_prompt(tokenizer_two, prompts, add_special_tokens) + + if args.cache_latents: + model_input = latents_cache[step].sample() + else: + pixel_values = batch["pixel_values"].to(dtype=vae.dtype) + model_input = vae.encode(pixel_values).latent_dist.sample() + + model_input = model_input * vae_scaling_factor + if args.pretrained_vae_model_name_or_path is None: + model_input = model_input.to(weight_dtype) + + # Sample noise that we'll add to the latents + noise = torch.randn_like(model_input) + bsz = model_input.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device + ) + timesteps = timesteps.long() + + # Add noise to the model input according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_model_input = noise_scheduler.add_noise(model_input, noise, timesteps) + + # Calculate the elements to repeat depending on the use of prior-preservation and custom captions. + if not train_dataset.custom_instance_prompts: + elems_to_repeat_text_embeds = bsz // 2 if args.with_prior_preservation else bsz + elems_to_repeat_time_ids = bsz // 2 if args.with_prior_preservation else bsz + + else: + elems_to_repeat_text_embeds = 1 + elems_to_repeat_time_ids = bsz // 2 if args.with_prior_preservation else bsz + + # Predict the noise residual + if freeze_text_encoder: + unet_added_conditions = { + "time_ids": add_time_ids.repeat(elems_to_repeat_time_ids, 1), + "text_embeds": unet_add_text_embeds.repeat(elems_to_repeat_text_embeds, 1), + } + prompt_embeds_input = prompt_embeds.repeat(elems_to_repeat_text_embeds, 1, 1) + model_pred = unet( + noisy_model_input, + timesteps, + prompt_embeds_input, + added_cond_kwargs=unet_added_conditions, + ).sample + else: + unet_added_conditions = {"time_ids": add_time_ids.repeat(elems_to_repeat_time_ids, 1)} + prompt_embeds, pooled_prompt_embeds = encode_prompt( + text_encoders=[text_encoder_one, text_encoder_two], + tokenizers=None, + prompt=None, + text_input_ids_list=[tokens_one, tokens_two], + ) + unet_added_conditions.update( + {"text_embeds": pooled_prompt_embeds.repeat(elems_to_repeat_text_embeds, 1)} + ) + prompt_embeds_input = prompt_embeds.repeat(elems_to_repeat_text_embeds, 1, 1) + model_pred = unet( + noisy_model_input, timesteps, prompt_embeds_input, added_cond_kwargs=unet_added_conditions + ).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(model_input, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute prior loss + prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean") + + if args.snr_gamma is None: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + else: + # Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556. + # Since we predict the noise instead of x_0, the original formulation is slightly changed. + # This is discussed in Section 4.2 of the same paper. + + if args.with_prior_preservation: + # if we're using prior preservation, we calc snr for instance loss only - + # and hence only need timesteps corresponding to instance images + snr_timesteps, _ = torch.chunk(timesteps, 2, dim=0) + else: + snr_timesteps = timesteps + + snr = compute_snr(noise_scheduler, snr_timesteps) + base_weight = ( + torch.stack([snr, args.snr_gamma * torch.ones_like(snr_timesteps)], dim=1).min(dim=1)[0] / snr + ) + + if noise_scheduler.config.prediction_type == "v_prediction": + # Velocity objective needs to be floored to an SNR weight of one. + mse_loss_weights = base_weight + 1 + else: + # Epsilon and sample both use the same loss weights. + mse_loss_weights = base_weight + + loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") + loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights + loss = loss.mean() + + if args.with_prior_preservation: + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + + accelerator.backward(loss) + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(unet_lora_parameters, text_lora_parameters_one, text_lora_parameters_two) + if (args.train_text_encoder or args.train_text_encoder_ti) + else unet_lora_parameters + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # every step, we reset the embeddings to the original embeddings. + if args.train_text_encoder_ti: + for idx, text_encoder in enumerate(text_encoders): + embedding_handler.retract_embeddings() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + global_step += 1 + + if accelerator.is_main_process: + if global_step % args.checkpointing_steps == 0: + # _before_ saving state, check if this save would set us over the `checkpoints_total_limit` + if args.checkpoints_total_limit is not None: + checkpoints = os.listdir(args.output_dir) + checkpoints = [d for d in checkpoints if d.startswith("checkpoint")] + checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1])) + + # before we save the new checkpoint, we need to have at _most_ `checkpoints_total_limit - 1` checkpoints + if len(checkpoints) >= args.checkpoints_total_limit: + num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1 + removing_checkpoints = checkpoints[0:num_to_remove] + + logger.info( + f"{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints" + ) + logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}") + + for removing_checkpoint in removing_checkpoints: + removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint) + shutil.rmtree(removing_checkpoint) + + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + accelerator.save_state(save_path) + logger.info(f"Saved state to {save_path}") + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if global_step >= args.max_train_steps: + break + + if accelerator.is_main_process: + if args.validation_prompt is not None and epoch % args.validation_epochs == 0: + logger.info( + f"Running validation... \n Generating {args.num_validation_images} images with prompt:" + f" {args.validation_prompt}." + ) + # create pipeline + if freeze_text_encoder: + text_encoder_one = text_encoder_cls_one.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="text_encoder", + revision=args.revision, + variant=args.variant, + ) + text_encoder_two = text_encoder_cls_two.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="text_encoder_2", + revision=args.revision, + variant=args.variant, + ) + pipeline = StableDiffusionXLPipeline.from_pretrained( + args.pretrained_model_name_or_path, + vae=vae, + text_encoder=accelerator.unwrap_model(text_encoder_one), + text_encoder_2=accelerator.unwrap_model(text_encoder_two), + unet=accelerator.unwrap_model(unet), + revision=args.revision, + variant=args.variant, + torch_dtype=weight_dtype, + ) + + # We train on the simplified learning objective. If we were previously predicting a variance, we need the scheduler to ignore it + scheduler_args = {} + + if "variance_type" in pipeline.scheduler.config: + variance_type = pipeline.scheduler.config.variance_type + + if variance_type in ["learned", "learned_range"]: + variance_type = "fixed_small" + + scheduler_args["variance_type"] = variance_type + + pipeline.scheduler = DPMSolverMultistepScheduler.from_config( + pipeline.scheduler.config, **scheduler_args + ) + + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) if args.seed else None + pipeline_args = {"prompt": args.validation_prompt} + + with torch.cuda.amp.autocast(): + images = [ + pipeline(**pipeline_args, generator=generator).images[0] + for _ in range(args.num_validation_images) + ] + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{i}: {args.validation_prompt}") + for i, image in enumerate(images) + ] + } + ) + + del pipeline + torch.cuda.empty_cache() + + # Save the lora layers + accelerator.wait_for_everyone() + if accelerator.is_main_process: + unet = accelerator.unwrap_model(unet) + unet = unet.to(torch.float32) + unet_lora_layers = convert_state_dict_to_diffusers(get_peft_model_state_dict(unet)) + + if args.train_text_encoder: + text_encoder_one = accelerator.unwrap_model(text_encoder_one) + text_encoder_lora_layers = convert_state_dict_to_diffusers( + get_peft_model_state_dict(text_encoder_one.to(torch.float32)) + ) + text_encoder_two = accelerator.unwrap_model(text_encoder_two) + text_encoder_2_lora_layers = convert_state_dict_to_diffusers( + get_peft_model_state_dict(text_encoder_two.to(torch.float32)) + ) + else: + text_encoder_lora_layers = None + text_encoder_2_lora_layers = None + + StableDiffusionXLPipeline.save_lora_weights( + save_directory=args.output_dir, + unet_lora_layers=unet_lora_layers, + text_encoder_lora_layers=text_encoder_lora_layers, + text_encoder_2_lora_layers=text_encoder_2_lora_layers, + ) + images = [] + if args.validation_prompt and args.num_validation_images > 0: + # Final inference + # Load previous pipeline + vae = AutoencoderKL.from_pretrained( + vae_path, + subfolder="vae" if args.pretrained_vae_model_name_or_path is None else None, + revision=args.revision, + variant=args.variant, + torch_dtype=weight_dtype, + ) + pipeline = StableDiffusionXLPipeline.from_pretrained( + args.pretrained_model_name_or_path, + vae=vae, + revision=args.revision, + variant=args.variant, + torch_dtype=weight_dtype, + ) + + # We train on the simplified learning objective. If we were previously predicting a variance, we need the scheduler to ignore it + scheduler_args = {} + + if "variance_type" in pipeline.scheduler.config: + variance_type = pipeline.scheduler.config.variance_type + + if variance_type in ["learned", "learned_range"]: + variance_type = "fixed_small" + + scheduler_args["variance_type"] = variance_type + + pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config, **scheduler_args) + + # load attention processors + pipeline.load_lora_weights(args.output_dir) + + # run inference + pipeline = pipeline.to(accelerator.device) + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) if args.seed else None + images = [ + pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0] + for _ in range(args.num_validation_images) + ] + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("test", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + tracker.log( + { + "test": [ + wandb.Image(image, caption=f"{i}: {args.validation_prompt}") + for i, image in enumerate(images) + ] + } + ) + + if args.train_text_encoder_ti: + embedding_handler.save_embeddings( + f"{args.output_dir}/{args.output_dir}_emb.safetensors", + ) + + # Conver to WebUI format + lora_state_dict = load_file(f"{args.output_dir}/pytorch_lora_weights.safetensors") + peft_state_dict = convert_all_state_dict_to_peft(lora_state_dict) + kohya_state_dict = convert_state_dict_to_kohya(peft_state_dict) + save_file(kohya_state_dict, f"{args.output_dir}/{args.output_dir}.safetensors") + + save_model_card( + model_id if not args.push_to_hub else repo_id, + images=images, + base_model=args.pretrained_model_name_or_path, + train_text_encoder=args.train_text_encoder, + train_text_encoder_ti=args.train_text_encoder_ti, + token_abstraction_dict=train_dataset.token_abstraction_dict, + instance_prompt=args.instance_prompt, + validation_prompt=args.validation_prompt, + repo_folder=args.output_dir, + vae_path=args.pretrained_vae_model_name_or_path, + ) + if args.push_to_hub: + upload_folder( + repo_id=repo_id, + folder_path=args.output_dir, + commit_message="End of training", + ignore_patterns=["step_*", "epoch_*"], + ) + + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args)