Upload folder using huggingface_hub

.github/workflows/issue-translator.yml

@@ -0,0 +1,18 @@
+name: 'issue-translator'
+on: 
+  issue_comment: 
+    types: [created]
+  issues: 
+    types: [opened]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: usthe/[email protected]
+        with:
+          IS_MODIFY_TITLE: false
+          # not require, default false, . Decide whether to modify the issue title
+          # if true, the robot account @Issues-translate-bot must have modification permissions, invite @Issues-translate-bot to your project or use your custom bot.
+          CUSTOM_BOT_NOTE: Bot detected the issue body's language is not English, translate it automatically. 👯👭🏻🧑‍🤝‍🧑👫🧑🏿‍🤝‍🧑🏻👩🏾‍🤝‍👨🏿👬🏿
+          # not require. Customize the translation robot prefix message.

.gitignore

@@ -0,0 +1,4 @@
+/checkpoint
+/logs
+/runs
+pipline.sh

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,12 +1,176 @@
----
-title: Medical Segment Anything Adapter
-emoji: 🔥
-colorFrom: gray
-colorTo: pink
-sdk: gradio
-sdk_version: 4.37.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<h1 align="center">● Medical SAM Adapter</h1>
+
+<p align="center">
+    <a href="https://discord.gg/DN4rvk95CC">
+        <img alt="Discord" src="https://img.shields.io/discord/1146610656779440188?logo=discord&style=flat&logoColor=white"/></a>
+    <img src="https://img.shields.io/static/v1?label=license&message=GPL&color=white&style=flat" alt="License"/>
+</p>
+
+Medical SAM Adapter, or say MSA, is a project to fineturn [SAM](https://github.com/facebookresearch/segment-anything) using [Adaption](https://lightning.ai/pages/community/tutorial/lora-llm/) for the Medical Imaging.
+This method is elaborated on the paper [Medical SAM Adapter: Adapting Segment Anything Model for Medical Image Segmentation](https://arxiv.org/abs/2304.12620).
+
+## A Quick Overview 
+ <img width="880" height="380" src="https://github.com/WuJunde/Medical-SAM-Adapter/blob/main/figs/medsamadpt.jpeg">
+
+ ## News
+ - [TOP] Join in our [Discord](https://discord.gg/EqbgSPEX) to ask questions and discuss with others.
+ - [TOP] 24-03-02 We have released our pre-trained Adapters in [Medical-Adapter-Zoo](https://huggingface.co/KidsWithTokens/Medical-Adapter-Zoo/tree/main). Try it without painful training 😉 Credit: @shinning0821
+ - 23-05-10. This project is still quickly updating 🌝. Check TODO list to see what will be released next.
+ - 23-05-11. GitHub Dicussion opened. You guys can now talk, code and make friends on the playground 👨‍❤️‍👨. 
+ - 23-12-22. Released data loader and example case on [REFUGE](https://refuge.grand-challenge.org/) dataset. Credit: @jiayuanz3
+ - 24-01-04. Released the Efficient Med-SAM-Adapter❗️ A new, faster, and more lightweight version incorporates Meta [EfficientSAM](https://yformer.github.io/efficient-sam/)🏇. Full credit goes to @shinning0821. 
+ - 24-01-07. The image resolution now can be resized by ``-image_size``. Credit: @shinning0821
+ - 24-01-11. Added a detailed guide on utilizing the Efficient Med-SAM-Adapter, complete with a comparison of performance and speed. You can find this resource in  [guidance/efficient_sam.ipynb](./guidance/efficient_sam.ipynb). Credit: @shinning0821
+ - 24-01-14. We've just launched our first official version, v0.1.0-alpha 🥳. This release includes support for [MobileSAM](https://github.com/ChaoningZhang/MobileSAM), which can be activated by setting ``-net mobile_sam``. Additionally, you now have the flexibility to use ViT, Tiny ViT, and Efficient ViT as encoders. Check the details [here](https://github.com/KidsWithTokens/Medical-SAM-Adapter/releases/tag/v0.1.0-alpha). Credit: @shinning0821
+ - 24-01-20. Added a guide on utilizing the mobile sam in Med-SAM-Adapter, with a comparison of performance and speed. You can find it in [guidance/mobile_sam.ipynb](https://github.com/KidsWithTokens/Medical-SAM-Adapter/blob/main/guidance/mobile_sam.ipynb) Credit: @shinning0821
+ - 24-01-21. We've added [LoRA](https://huggingface.co/docs/diffusers/training/lora) to our framework🤖. Use it by setting ``-mod`` as ``sam_lora``.
+A guidance can be found in [here](https://github.com/KidsWithTokens/Medical-SAM-Adapter/blob/main/guidance/lora.ipynb). Credit: @shinning0821
+ - 24-01-22. We've added dataloader for [LIDC dataset](https://paperswithcode.com/dataset/lidc-idri), a multi-rater(4 raters 👨‍⚕️🧑🏽‍⚕️👩‍⚕️🧑🏽‍⚕️) lesions segmentation from low-dose lung CTs 🩻. You can download the preprocessed LIDC dataset at [here](https://github.com/stefanknegt/Probabilistic-Unet-Pytorch). Also updated environment, and random_click function. Credit: @jiayuanz3
+ - 24-03-06. We've supported multi-class segmentation. Use it by setting ``-multimask_output`` to the number of classes favored. Also updated REFUGE example to two classes (optic disc & cup). Credit: @LJQCN101
+ - 24-03-06. We've supported many other datasets and rebuild the code of datasets and dataloaders. Seen in `guidance/Dataset.md` Credit: @shinning0821
+
+## Medical Adapter Zoo 🐘🐊🦍🦒🦨🦜🦥
+We've released a bunch of pre-trained Adapters for various organs/lesions in [Medical-Adapter-Zoo](https://huggingface.co/KidsWithTokens/Medical-Adapter-Zoo/tree/main). Just pick the adapter that matches your disease and easily adjust SAM to suit your specific needs 😉. 
+
+If you can't find what you're looking for. Please suggest it through any contact method available to us (GitHub issue, HuggingFace community, or [Discord](https://discord.gg/EqbgSPEX)). We'll do our very best to include it.
+ 
+ ## Requirement
+
+ Install the environment:
+
+ ``conda env create -f environment.yml``
+
+ ``conda activate sam_adapt``
+
+ Then download [SAM checkpoint](https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth), and put it at ./checkpoint/sam/
+
+ You can run:
+
+ ``wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth``
+
+ ``mv sam_vit_b_01ec64.pth ./checkpoint/sam``
+ creat the folder if it does not exist
+
+ ## Example Cases
+
+ ### Melanoma Segmentation from Skin Images (2D)
+
+ 1. Download ISIC dataset part 1 from https://challenge.isic-archive.com/data/. Then put the csv files in "./data/isic" under your data path. Your dataset folder under "your_data_path" should be like:
+ISIC/
+     ISBI2016_ISIC_Part1_Test_Data/...
+     
+     ISBI2016_ISIC_Part1_Training_Data/...
+     
+     ISBI2016_ISIC_Part1_Test_GroundTruth.csv
+     
+      ISBI2016_ISIC_Part1_Training_GroundTruth.csv
+    
+    You can fine the csv files [here](https://github.com/KidsWithTokens/MedSegDiff/tree/master/data/isic_csv)
+
+ 3. Begin Adapting! run: ``python train.py -net sam -mod sam_adpt -exp_name *msa_test_isic* -sam_ckpt ./checkpoint/sam/sam_vit_b_01ec64.pth -image_size 1024 -b 32 -dataset isic -data_path *../data*``
+ change "data_path" and "exp_name" for your own useage. you can change "exp_name" to anything you want.
+
+ You can descrease the ``image size`` or batch size ``b`` if out of memory.
+
+ 3. Evaluation: The code can automatically evaluate the model on the test set during traing, set "--val_freq" to control how many epoches you want to evaluate once. You can also run val.py for the independent evaluation.
+
+ 4. Result Visualization: You can set "--vis" parameter to control how many epoches you want to see the results in the training or evaluation process.
+
+ In default, everything will be saved at `` ./logs/`` 
+
+ ### REFUGE: Optic-disc Segmentation from Fundus Images (2D) 
+ [REFUGE](https://refuge.grand-challenge.org/) dataset contains 1200 fundus images with optic disc/cup segmentations and clinical glaucoma labels. 
+
+ 1. Dowaload the dataset manually from [here](https://huggingface.co/datasets/realslimman/REFUGE-MultiRater/tree/main), or using command lines:
+
+ ``git lfs install``
+
+ ``git clone [email protected]:datasets/realslimman/REFUGE-MultiRater``
+
+ unzip and put the dataset to the target folder
+
+ ``unzip ./REFUGE-MultiRater.zip``
+
+ ``mv REFUGE-MultiRater ./data``
+
+ 2. For training the adapter, run: ``python train.py -net sam -mod sam_adpt -exp_name REFUGE-MSAdapt -sam_ckpt ./checkpoint/sam/sam_vit_b_01ec64.pth -image_size 1024 -b 32 -dataset REFUGE -data_path ./data/REFUGE-MultiRater``
+ you can change "exp_name" to anything you want.
+
+ You can descrease the ``image size`` or batch size ``b`` if out of memory.
+
+ ### Abdominal Multiple Organs Segmentation (3D)
+
+ This tutorial demonstrates how MSA can adapt SAM to 3D multi-organ segmentation task using the BTCV challenge dataset.
+For BTCV dataset, under Institutional Review Board (IRB) supervision, 50 abdomen CT scans of were randomly selected from a combination of an ongoing colorectal cancer chemotherapy trial, and a retrospective ventral hernia study. The 50 scans were captured during portal venous contrast phase with variable volume sizes (512 x 512 x 85 - 512 x 512 x 198) and field of views (approx. 280 x 280 x 280 mm3 - 500 x 500 x 650 mm3). The in-plane resolution varies from 0.54 x 0.54 mm2 to 0.98 x 0.98 mm2, while the slice thickness ranges from 2.5 mm to 5.0 mm.
+Target: 13 abdominal organs including
+Spleen
+Right Kidney
+Left Kidney
+Gallbladder
+Esophagus
+Liver
+Stomach
+Aorta
+IVC
+Portal and Splenic Veins
+Pancreas
+Right adrenal gland
+Left adrenal gland.
+Modality: CT
+Size: 30 3D volumes (24 Training + 6 Testing)
+Challenge: BTCV MICCAI Challenge
+The following figure shows image patches with the organ sub-regions that are annotated in the CT (top left) and the final labels for the whole dataset (right).
+1. Prepare BTCV dataset following [MONAI](https://docs.monai.io/en/stable/index.html) instruction:
+Download BTCV dataset from: https://www.synapse.org/#!Synapse:syn3193805/wiki/217752. After you open the link, navigate to the "Files" tab, then download Abdomen/RawData.zip.
+After downloading the zip file, unzip. Then put images from RawData/Training/img in ../data/imagesTr, and put labels from RawData/Training/label in ../data/labelsTr.
+Download the json file for data splits from this [link](https://drive.google.com/file/d/1qcGh41p-rI3H_sQ0JwOAhNiQSXriQqGi/view). Place the JSON file at ../data/dataset_0.json.
+2. For the Adaptation, run: ``python train.py -net sam -mod sam_adpt -exp_name msa-3d-sam-btcv -sam_ckpt ./checkpoint/sam/sam_vit_b_01ec64.pth -image_size 1024 -b 8 -dataset decathlon -thd True -chunk 96 -data_path ../data -num_sample 4``  
+You can modify following parameters to save the memory usage: '-b' the batch size, '-chunk' the 3D depth (channel) for each sample, '-num_sample' number of samples for [Monai.RandCropByPosNegLabeld](https://docs.monai.io/en/stable/transforms.html#randcropbyposneglabeld), 'evl_chunk' the 3D channel split step in the evaluation, decrease it if out of memory in the evaluation. 
+## Run on  your own dataset
+It is simple to run MSA on the other datasets. Just write another dataset class following which in `` ./dataset.py``. You only need to make sure you return a dict with 
+     {
+                 'image': A tensor saving images with size [C,H,W] for 2D image, size [C, H, W, D] for 3D data.
+                 D is the depth of 3D volume, C is the channel of a scan/frame, which is commonly 1 for CT, MRI, US data. 
+                 If processing, say like a colorful surgical video, D could the number of time frames, and C will be 3 for a RGB frame.
+                 'label': The target masks. Same size with the images except the resolutions (H and W).
+                 'p_label': The prompt label to decide positive/negative prompt. To simplify, you can always set 1 if don't need the negative prompt function.
+                 'pt': The prompt. Should be the same as that in SAM, e.g., a click prompt should be [x of click, y of click], one click for each scan/frame if using 3d data.
+                 'image_meta_dict': Optional. if you want save/visulize the result, you should put the name of the image in it with the key ['filename_or_obj'].
+                 ...(others as you want)
+     }
+Welcome to open issues if you meet any problem. It would be appreciated if you could contribute your dataset extensions. Unlike natural images, medical images vary a lot depending on different tasks. Expanding the generalization of a method requires everyone's efforts.
+
+ ### TODO LIST
+
+- [ ] Jupyter tutorials.
+- [x] Fix bugs in BTCV. Add BTCV example.
+- [ ] Release REFUGE2, BraTs dataloaders and examples
+- [x] Changable Image Resolution 
+- [ ] Fix bugs in Multi-GPU parallel
+- [x] Sample and Vis in training
+- [ ] Release general data pre-processing and post-processing
+- [x] Release evaluation
+- [ ] Deploy on HuggingFace
+- [x] configuration
+- [ ] Release SSL code
+- [ ] Release Medical Adapter Zoo
+
+ ## Cite
+ ~~~
+@misc{wu2023medical,
+      title={Medical SAM Adapter: Adapting Segment Anything Model for Medical Image Segmentation}, 
+      author={Junde Wu and Wei Ji and Yuanpei Liu and Huazhu Fu and Min Xu and Yanwu Xu and Yueming Jin},
+      year={2023},
+      eprint={2304.12620},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+ ~~~
+
+## Buy Me A Coffee 🥤😉
+https://ko-fi.com/jundewu
+
+
+
+
+

cfg.py

@@ -0,0 +1,59 @@
+import argparse
+
+
+def parse_args():    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-net', type=str, default='sam', help='net type')
+    parser.add_argument('-baseline', type=str, default='unet', help='baseline net type')
+    parser.add_argument('-encoder', type=str, default='default', help='encoder type')
+    parser.add_argument('-seg_net', type=str, default='transunet', help='net type')
+    parser.add_argument('-mod', type=str, default='sam_adpt', help='mod type:seg,cls,val_ad')
+    parser.add_argument('-exp_name', default='msa_test_isic', type=str, help='net type')
+    parser.add_argument('-type', type=str, default='map', help='condition type:ave,rand,rand_map')
+    parser.add_argument('-vis', type=int, default=None, help='visualization')
+    parser.add_argument('-reverse', type=bool, default=False, help='adversary reverse')
+    parser.add_argument('-pretrain', type=bool, default=False, help='adversary reverse')
+    parser.add_argument('-val_freq',type=int,default=5,help='interval between each validation')
+    parser.add_argument('-gpu', type=bool, default=True, help='use gpu or not')
+    parser.add_argument('-gpu_device', type=int, default=0, help='use which gpu')
+    parser.add_argument('-sim_gpu', type=int, default=0, help='split sim to this gpu')
+    parser.add_argument('-epoch_ini', type=int, default=1, help='start epoch')
+    parser.add_argument('-image_size', type=int, default=256, help='image_size')
+    parser.add_argument('-out_size', type=int, default=256, help='output_size')
+    parser.add_argument('-patch_size', type=int, default=2, help='patch_size')
+    parser.add_argument('-dim', type=int, default=512, help='dim_size')
+    parser.add_argument('-depth', type=int, default=1, help='depth')
+    parser.add_argument('-heads', type=int, default=16, help='heads number')
+    parser.add_argument('-mlp_dim', type=int, default=1024, help='mlp_dim')
+    parser.add_argument('-w', type=int, default=4, help='number of workers for dataloader')
+    parser.add_argument('-b', type=int, default=2, help='batch size for dataloader')
+    parser.add_argument('-s', type=bool, default=True, help='whether shuffle the dataset')
+    parser.add_argument('-warm', type=int, default=1, help='warm up training phase')
+    parser.add_argument('-lr', type=float, default=1e-4, help='initial learning rate')
+    parser.add_argument('-uinch', type=int, default=1, help='input channel of unet')
+    parser.add_argument('-imp_lr', type=float, default=3e-4, help='implicit learning rate')
+    parser.add_argument('-weights', type=str, default = 0, help='the weights file you want to test')
+    parser.add_argument('-base_weights', type=str, default = 0, help='the weights baseline')
+    parser.add_argument('-sim_weights', type=str, default = 0, help='the weights sim')
+    parser.add_argument('-distributed', default='none' ,type=str,help='multi GPU ids to use')
+    parser.add_argument('-dataset', default='isic' ,type=str,help='dataset name')
+    parser.add_argument('-sam_ckpt', default=None , help='sam checkpoint address')
+    parser.add_argument('-thd', type=bool, default=False , help='3d or not')
+    parser.add_argument('-chunk', type=int, default=None , help='crop volume depth')
+    parser.add_argument('-num_sample', type=int, default=4 , help='sample pos and neg')
+    parser.add_argument('-roi_size', type=int, default=96 , help='resolution of roi')
+    parser.add_argument('-evl_chunk', type=int, default=None , help='evaluation chunk')
+    parser.add_argument('-mid_dim', type=int, default=None , help='middle dim of adapter or the rank of lora matrix')
+    parser.add_argument('-multimask_output', type=int, default=1 , help='the number of masks output for multi-class segmentation, set 2 for REFUGE dataset.')
+    parser.add_argument(
+    '-data_path',
+    type=str,
+    default='../data',
+    help='The path of segmentation data')
+    # '../dataset/RIGA/DiscRegion'
+    # '../dataset/ISIC'
+    opt = parser.parse_args()
+
+    return opt
+
+# required=True, 

conf/__init__.py

@@ -0,0 +1,15 @@
+""" dynamically load settings
+
+author baiyu
+"""
+import conf.global_settings as settings
+
+
+class Settings:
+    def __init__(self, settings):
+
+        for attr in dir(settings):
+            if attr.isupper():
+                setattr(self, attr, getattr(settings, attr))
+
+settings = Settings(settings)

conf/global_settings.py

@@ -0,0 +1,54 @@
+""" configurations for this project
+
+author Junde
+"""
+import os
+from datetime import datetime
+
+#CIFAR100 dataset path (python version)
+#CIFAR100_PATH = '/nfs/private/cifar100/cifar-100-python'
+
+#mean and std of cifar100 dataset
+CIFAR100_TRAIN_MEAN = (0.5070751592371323, 0.48654887331495095, 0.4409178433670343)
+CIFAR100_TRAIN_STD = (0.2673342858792401, 0.2564384629170883, 0.27615047132568404)
+
+GLAUCOMA_TRAIN_MEAN = (0.5070751592371323, 0.48654887331495095, 0.4409178433670343)
+GLAUCOMA_TRAIN_STD = (0.2673342858792401, 0.2564384629170883, 0.27615047132568404)
+
+MASK_TRAIN_MEAN = (2.654204690220496/255)
+MASK_TRAIN_STD = (21.46473779720519/255)
+
+#CIFAR100_TEST_MEAN = (0.5088964127604166, 0.48739301317401956, 0.44194221124387256)
+#CIFAR100_TEST_STD = (0.2682515741720801, 0.2573637364478126, 0.2770957707973042)
+
+#directory to save weights file
+CHECKPOINT_PATH = 'checkpoint'
+
+#total training epoches
+EPOCH = 100 
+step_size = 10
+i = 1
+MILESTONES = []
+while i * 5 <= EPOCH:
+    MILESTONES.append(i* step_size)
+    i += 1
+
+#initial learning rate
+#INIT_LR = 0.1
+
+#time of we run the script
+TIME_NOW = datetime.now().strftime("%F_%H-%M-%S.%f")
+
+#tensorboard log dir
+LOG_DIR = 'runs'
+
+#save weights file per SAVE_EPOCH epoch
+SAVE_EPOCH = 10
+
+
+
+
+
+
+
+

dataset/__init__.py

@@ -0,0 +1,230 @@
+import numpy as np
+import torchvision.transforms as transforms
+from torch.utils.data import DataLoader, random_split
+from torch.utils.data.sampler import SubsetRandomSampler
+
+from utils import *
+
+from .atlas import Atlas
+from .brat import Brat
+from .ddti import DDTI
+from .isic import ISIC2016
+from .kits import KITS
+from .lidc import LIDC
+from .lnq import LNQ
+from .pendal import Pendal
+from .refuge import REFUGE
+from .segrap import SegRap
+from .stare import STARE
+from .toothfairy import ToothFairy
+from .wbc import WBC
+
+
+def get_dataloader(args):
+    transform_train = transforms.Compose([
+        transforms.Resize((args.image_size,args.image_size)),
+        transforms.ToTensor(),
+    ])
+
+    transform_train_seg = transforms.Compose([
+        transforms.Resize((args.out_size,args.out_size)),
+        transforms.ToTensor(),
+    ])
+
+    transform_test = transforms.Compose([
+        transforms.Resize((args.image_size, args.image_size)),
+        transforms.ToTensor(),
+    ])
+
+    transform_test_seg = transforms.Compose([
+        transforms.Resize((args.out_size,args.out_size)),
+        transforms.ToTensor(),
+    ])
+    
+    if args.dataset == 'isic':
+        '''isic data'''
+        isic_train_dataset = ISIC2016(args, args.data_path, transform = transform_train, transform_msk= transform_train_seg, mode = 'Training')
+        isic_test_dataset = ISIC2016(args, args.data_path, transform = transform_test, transform_msk= transform_test_seg, mode = 'Test')
+
+        nice_train_loader = DataLoader(isic_train_dataset, batch_size=args.b, shuffle=True, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(isic_test_dataset, batch_size=args.b, shuffle=False, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'decathlon':
+        nice_train_loader, nice_test_loader, transform_train, transform_val, train_list, val_list = get_decath_loader(args)
+
+
+    elif args.dataset == 'REFUGE':
+        '''REFUGE data'''
+        refuge_train_dataset = REFUGE(args, args.data_path, transform = transform_train, transform_msk= transform_train_seg, mode = 'Training')
+        refuge_test_dataset = REFUGE(args, args.data_path, transform = transform_test, transform_msk= transform_test_seg, mode = 'Test')
+
+        nice_train_loader = DataLoader(refuge_train_dataset, batch_size=args.b, shuffle=True, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(refuge_test_dataset, batch_size=args.b, shuffle=False, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'LIDC':
+        '''LIDC data'''
+        # dataset = LIDC(data_path = args.data_path)
+        dataset = MyLIDC(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.2 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'DDTI':
+        '''DDTI data'''
+        refuge_train_dataset = DDTI(args, args.data_path, transform = transform_train, transform_msk= transform_train_seg, mode = 'Training')
+        refuge_test_dataset = DDTI(args, args.data_path, transform = transform_test, transform_msk= transform_test_seg, mode = 'Test')
+
+        nice_train_loader = DataLoader(refuge_train_dataset, batch_size=args.b, shuffle=True, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(refuge_test_dataset, batch_size=args.b, shuffle=False, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'Brat':
+        '''Brat data'''
+        dataset = Brat(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'STARE':
+        '''STARE data'''
+        # dataset = LIDC(data_path = args.data_path)
+        dataset = STARE(args, data_path = args.data_path, transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.2 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'kits':
+        '''kits data'''
+        dataset = KITS(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'WBC':
+        '''WBC data'''
+        dataset = WBC(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'segrap':
+        '''segrap data'''
+        dataset = SegRap(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'toothfairy':
+        '''toothfairy data'''
+        dataset = ToothFairy(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'atlas':
+        '''atlas data'''
+        dataset = Atlas(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'pendal':
+        '''pendal data'''
+        dataset = Pendal(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    elif args.dataset == 'lnq':
+        '''lnq data'''
+        dataset = LNQ(args, data_path = args.data_path,transform = transform_train, transform_msk= transform_train_seg)
+
+        dataset_size = len(dataset)
+        indices = list(range(dataset_size))
+        split = int(np.floor(0.3 * dataset_size))
+        np.random.shuffle(indices)
+        train_sampler = SubsetRandomSampler(indices[split:])
+        test_sampler = SubsetRandomSampler(indices[:split])
+
+        nice_train_loader = DataLoader(dataset, batch_size=args.b, sampler=train_sampler, num_workers=8, pin_memory=True)
+        nice_test_loader = DataLoader(dataset, batch_size=args.b, sampler=test_sampler, num_workers=8, pin_memory=True)
+        '''end'''
+
+    else:
+        print("the dataset is not supported now!!!")
+        
+    return nice_train_loader, nice_test_loader

dataset/atlas.py

@@ -0,0 +1,86 @@
+import json
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class Atlas(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+
+        self.args = args
+        self.data_path = os.path.join(data_path,'train')
+        with open(os.path.join(self.data_path,'dataset.json'),'r') as file:
+            data = json.load(file)
+        self.name_list = data['training']
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+
+    def __getitem__(self, index):
+        point_label = 1
+        label = 1 
+
+        """Get the images"""
+        img_name = self.name_list[index]['image']
+        mask_name = self.name_list[index]['label']
+
+        img = nib.load(os.path.join(self.data_path,img_name)).get_fdata()
+        mask = nib.load(os.path.join(self.data_path,mask_name)).get_fdata()
+
+        mask[mask!=label] = 0
+        mask[mask==label] = 1
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+        img = np.transpose(img,(1,2,0))
+        mask = np.transpose(mask,(1,2,0))
+
+        # img = np.resize(mask,(self.args.image_size, self.args.image_size,128))
+        # mask = np.resize(mask,(self.args.out_size,self.args.out_size,128))
+
+        # # img = np.resize(img,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        # # mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = torch.tensor(img).unsqueeze(0)
+        mask = torch.tensor(mask).unsqueeze(0)
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask), point_label)
+        # if self.transform:
+        #     state = torch.get_rng_state()
+        #     img = self.transform(img)
+        #     torch.set_rng_state(state)
+
+        #     if self.transform_msk:
+        #         mask = self.transform_msk(mask)
+                
+        #     # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+        #     #     mask = 1 - mask
+        name = img_name
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/brat.py

@@ -0,0 +1,90 @@
+import os
+import pickle
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class Brat(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        self.args = args
+        self.data_path = os.path.join(data_path,'Data')
+        self.name_list = os.listdir(self.data_path)
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+    def load_all_levels(self,path):
+        import nibabel as nib
+        data_dir = os.path.join(self.data_path)
+        levels = ['t1','flair','t2','t1ce']
+        raw_image = [nib.load(os.path.join
+        (data_dir,path,path+'_'+level+'.nii.gz')).get_fdata() for level in levels]
+        raw_seg = nib.load(os.path.join(data_dir,path,path+'_seg.nii.gz')).get_fdata()
+
+        return raw_image[0], raw_seg
+
+    def __getitem__(self, index):
+        # if self.mode == 'Training':
+        #     point_label = random.randint(0, 1)
+        #     inout = random.randint(0, 1)
+        # else:
+        #     inout = 1
+        #     point_label = 1
+        point_label = 1
+        label = 4   # the class to be segmented
+
+        """Get the images"""
+        name = self.name_list[index]
+        img,mask = self.load_all_levels(name)
+
+        mask[mask!=label] = 0
+        mask[mask==label] = 1
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+
+        
+        img = np.resize(img,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = torch.tensor(img).unsqueeze(0)
+        mask = torch.tensor(mask).unsqueeze(0)
+        mask = torch.clamp(mask,min=0,max=1).int()
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask), point_label)
+        # if self.transform:
+        #     state = torch.get_rng_state()
+        #     img = self.transform(img)
+        #     torch.set_rng_state(state)
+
+        #     if self.transform_msk:
+        #         mask = self.transform_msk(mask)
+                
+        #     # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+        #     #     mask = 1 - mask
+        name = name.split('/')[-1].split(".jpg")[0]
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/ddti.py

@@ -0,0 +1,99 @@
+import os
+
+import cv2
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import random_box, random_click
+
+
+class DDTI(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        self.name_list = os.listdir(os.path.join(data_path,mode,'images'))
+        self.data_path = data_path
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+    def find_connected_components(self,mask):
+        mask = np.clip(mask,0,1)
+        num_labels, labels = cv2.connectedComponents(mask.astype(np.uint8))
+        point = []
+        point_labels = []
+
+        for label in range(1, num_labels):
+            component_mask = np.where(labels == label, 1, 0)
+            area = np.sum(component_mask)
+
+            if area > 400:
+                point_label, random_point = random_click(component_mask)
+                point.append(random_point)
+                point_labels.append(point_label)
+                # print(f"Random point in component {label}: {random_point}, label: {point_labels}")
+        if(len(point)==1):
+            point.append(point[0])
+            point_labels.append(point_labels[0])
+        if(len(point)>2):
+            point = point[:2]
+            point_labels = point_labels[:2]
+        point = np.array(point)
+        point_labels = np.array(point_labels)
+        return point_labels,point
+    
+    def __getitem__(self, index):
+        point_label = 1
+
+        """Get the images"""
+        name = self.name_list[index]
+        img_path = os.path.join(self.data_path, self.mode, 'images', name)
+        msk_path = os.path.join(self.data_path, self.mode, 'masks', name)
+
+        img = Image.open(img_path).convert('RGB')
+        mask = Image.open(msk_path).convert('L')
+
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+
+        newsize = (self.img_size, self.img_size)
+        mask = mask.resize(newsize)
+
+        if self.prompt == 'click':
+            # two prompt
+            point_label, pt = self.find_connected_components(np.array(mask))
+            # one prompt
+            # point_label, pt = random_click(np.array(mask) / 255, point_label)
+
+        if self.transform:
+            state = torch.get_rng_state()
+            img = self.transform(img)
+            torch.set_rng_state(state)
+
+
+            if self.transform_msk:
+                mask = self.transform_msk(mask)
+                
+            # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+            #     mask = 1 - mask
+        mask = torch.clamp(mask,min=0,max=1).int()
+
+        name = name.split('/')[-1].split(".jpg")[0]
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }

dataset/isic.py

@@ -0,0 +1,78 @@
+import os
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import random_box, random_click
+
+
+class ISIC2016(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        df = pd.read_csv(os.path.join(data_path, 'ISBI2016_ISIC_Part1_' + mode + '_GroundTruth.csv'), encoding='gbk')
+        self.name_list = df.iloc[:,1].tolist()
+        self.label_list = df.iloc[:,2].tolist()
+        self.data_path = data_path
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+    def __getitem__(self, index):
+        # if self.mode == 'Training':
+        #     point_label = random.randint(0, 1)
+        #     inout = random.randint(0, 1)
+        # else:
+        #     inout = 1
+        #     point_label = 1
+        point_label = 1
+
+        """Get the images"""
+        name = self.name_list[index]
+        img_path = os.path.join(self.data_path, name)
+        
+        mask_name = self.label_list[index]
+        msk_path = os.path.join(self.data_path, mask_name)
+
+        img = Image.open(img_path).convert('RGB')
+        mask = Image.open(msk_path).convert('L')
+
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+
+        newsize = (self.img_size, self.img_size)
+        mask = mask.resize(newsize)
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask) / 255, point_label)
+
+        if self.transform:
+            state = torch.get_rng_state()
+            img = self.transform(img)
+            torch.set_rng_state(state)
+
+
+            if self.transform_msk:
+                mask = self.transform_msk(mask).int()
+                
+            # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+            #     mask = 1 - mask
+        name = name.split('/')[-1].split(".jpg")[0]
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }

dataset/kits.py

@@ -0,0 +1,87 @@
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class KITS(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+
+        self.args = args
+        self.data_path = os.path.join(data_path,'kits21','data')
+        self.name_list = os.listdir(self.data_path)
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+
+    def __getitem__(self, index):
+        # if self.mode == 'Training':
+        #     point_label = random.randint(0, 1)
+        #     inout = random.randint(0, 1)
+        # else:
+        #     inout = 1
+        #     point_label = 1
+        point_label = 1
+
+
+        """Get the images"""
+        name = self.name_list[index]
+        img = nib.load(os.path.join(self.data_path,name,'imaging.nii.gz')).get_fdata()
+        mask = nib.load(os.path.join(self.data_path,name,'aggregated_AND_seg.nii.gz')).get_fdata()
+
+        mask = np.clip(mask,0,1)
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+        img = np.transpose(img,(1,2,0))
+        mask = np.transpose(mask,(1,2,0))
+
+        # img = np.resize(mask,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        # mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = np.resize(img,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = torch.tensor(img).unsqueeze(0)
+        mask = torch.tensor(mask).unsqueeze(0)
+        mask = torch.clamp(mask,min=0,max=1).int()
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask), point_label)
+        # if self.transform:
+        #     state = torch.get_rng_state()
+        #     img = self.transform(img)
+        #     torch.set_rng_state(state)
+
+        #     if self.transform_msk:
+        #         mask = self.transform_msk(mask)
+                
+        #     # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+        #     #     mask = 1 - mask
+        name = name.split('/')[-1].split(".jpg")[0]
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/lidc.py

@@ -0,0 +1,96 @@
+import os
+import pickle
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import random_box, random_click
+
+
+class LIDC(Dataset):
+    names = []
+    images = []
+    labels = []
+    series_uid = []
+
+    def __init__(self, data_path, transform=None, transform_msk = None, prompt = 'click'):
+        self.prompt = prompt
+        self.transform = transform
+        self.transform_msk = transform_msk
+        
+        max_bytes = 2**31 - 1
+        data = {}
+        for file in os.listdir(data_path):
+            filename = os.fsdecode(file)
+            if '.pickle' in filename:
+                file_path = data_path + filename
+                bytes_in = bytearray(0)
+                input_size = os.path.getsize(file_path)
+                with open(file_path, 'rb') as f_in:
+                    for _ in range(0, input_size, max_bytes):
+                        bytes_in += f_in.read(max_bytes)
+                new_data = pickle.loads(bytes_in)
+                data.update(new_data)
+                
+        
+        for key, value in data.items():
+            self.names.append(key)
+            self.images.append(value['image'].astype(float))
+            self.labels.append(value['masks'])
+            self.series_uid.append(value['series_uid'])
+
+        assert (len(self.images) == len(self.labels) == len(self.series_uid))
+
+        for img in self.images:
+            assert np.max(img) <= 1 and np.min(img) >= 0
+        for label in self.labels:
+            assert np.max(label) <= 1 and np.min(label) >= 0
+
+        del new_data
+        del data
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, index):
+
+        point_label = 1
+
+        """Get the images"""
+        img = np.expand_dims(self.images[index], axis=0)
+        name = self.names[index]
+        multi_rater = self.labels[index]
+
+        # first click is the target most agreement among raters, otherwise, background agreement
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(np.mean(np.stack(multi_rater), axis=0)) / 255, point_label)
+
+        # Convert image (ensure three channels) and multi-rater labels to torch tensors
+        img = torch.from_numpy(img).type(torch.float32)
+        img = img.repeat(3, 1, 1) 
+        multi_rater = [torch.from_numpy(single_rater).type(torch.float32) for single_rater in multi_rater]
+
+        multi_rater = torch.stack(multi_rater, dim=0)
+        multi_rater = multi_rater.unsqueeze(1)
+
+        if self.prompt == 'box':
+            x_min, x_max, y_min, y_max = random_box(multi_rater)
+            box = [x_min, x_max, y_min, y_max]
+
+        mask = multi_rater.mean(dim=0) # average
+
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'multi_rater': multi_rater,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'box': box,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/lnq.py

@@ -0,0 +1,80 @@
+import json
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import SimpleITK as sitk
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class LNQ(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+
+        self.args = args
+        self.data_path = os.path.join(data_path,'train')
+
+        files = os.listdir(self.data_path)
+
+        self.name_list = [file for file in files if file.endswith('.png')]
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+
+    def __getitem__(self, index):
+        point_label = 1
+        label = 1 
+
+        """Get the images"""
+        name = self.name_list[index].split('.')[0]
+        img_name = name + '-ct.nrrd'
+        mask_name = name + '-seg.nrrd'
+
+        img = sitk.GetArrayFromImage(sitk.ReadImage(os.path.join(self.data_path,img_name)))
+        mask = sitk.GetArrayFromImage(sitk.ReadImage(os.path.join(self.data_path,mask_name)))
+
+        mask[mask!=label] = 0
+        mask[mask==label] = 1
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+        img = np.transpose(img,(1,2,0))
+        mask = np.transpose(mask,(1,2,0))
+
+        # img = np.resize(mask,(self.args.image_size, self.args.image_size,128))
+        # mask = np.resize(mask,(self.args.out_size,self.args.out_size,128))
+
+        # # img = np.resize(img,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        # # mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = torch.tensor(img).unsqueeze(0).int()
+        mask = torch.tensor(mask).unsqueeze(0).int()
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask), point_label)
+
+        name = img_name
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/pendal.py

@@ -0,0 +1,71 @@
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class Pendal(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        self.args = args
+        self.data_path = data_path
+        self.name_list = os.listdir(os.path.join(self.data_path,'Images'))
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+
+    def __getitem__(self, index):
+        # if self.mode == 'Training':
+        #     point_label = random.randint(0, 1)
+        #     inout = random.randint(0, 1)
+        # else:
+        #     inout = 1
+        #     point_label = 1
+        point_label = 1
+
+        """Get the images"""
+        name = self.name_list[index]
+        img = Image.open(os.path.join(self.data_path, 'Images',name)).convert('RGB')
+        mask = Image.open(os.path.join(self.data_path, 'Segmentation1',name)).convert('L')
+
+        mask = np.array(mask)
+        mask[mask==mask.min()]=0
+        mask[mask>0] = 255
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask) / 255, point_label)
+
+        if self.transform:
+            state = torch.get_rng_state()
+            img = self.transform(img)
+            torch.set_rng_state(state)
+
+
+            if self.transform_msk:
+                mask = Image.fromarray(mask)
+                mask = self.transform_msk(mask).int()
+
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/refuge.py

@@ -0,0 +1,91 @@
+import os
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import random_box, random_click
+
+
+class REFUGE(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'none', plane = False):
+        self.data_path = data_path
+        self.subfolders = [f.path for f in os.scandir(os.path.join(data_path, mode + '-400')) if f.is_dir()]
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+        self.mask_size = args.out_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.subfolders)
+
+    def __getitem__(self, index):
+        point_label = 1
+
+        """Get the images"""
+        subfolder = self.subfolders[index]
+        name = subfolder.split('/')[-1]
+
+        # raw image and raters path
+        img_path = os.path.join(subfolder, name + '.jpg')
+        multi_rater_cup_path = [os.path.join(subfolder, name + '_seg_cup_' + str(i) + '.png') for i in range(1, 8)]
+        multi_rater_disc_path = [os.path.join(subfolder, name + '_seg_disc_' + str(i) + '.png') for i in range(1, 8)]
+
+        # raw image and raters images
+        img = Image.open(img_path).convert('RGB')
+        multi_rater_cup = [Image.open(path).convert('L') for path in multi_rater_cup_path]
+        multi_rater_disc = [Image.open(path).convert('L') for path in multi_rater_disc_path]
+
+        # resize raters images for generating initial point click
+        newsize = (self.img_size, self.img_size)
+        multi_rater_cup_np = [np.array(single_rater.resize(newsize)) for single_rater in multi_rater_cup]
+        multi_rater_disc_np = [np.array(single_rater.resize(newsize)) for single_rater in multi_rater_disc]
+
+        # first click is the target agreement among most raters
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(np.mean(np.stack(multi_rater_cup_np), axis=0)) / 255, point_label)
+            point_label, pt_disc = random_click(np.array(np.mean(np.stack(multi_rater_disc_np), axis=0)) / 255, point_label)
+        else:
+            # you may want to get rid of click prompts
+            pt = np.array([0, 0], dtype=np.int32)
+            
+        if self.transform:
+            state = torch.get_rng_state()
+            img = self.transform(img)
+            multi_rater_cup = [torch.as_tensor((self.transform(single_rater) >0.5).float(), dtype=torch.float32) for single_rater in multi_rater_cup]
+            multi_rater_cup = torch.stack(multi_rater_cup, dim=0)
+            # transform to mask size (out_size) for mask define
+            mask_cup = F.interpolate(multi_rater_cup, size=(self.mask_size, self.mask_size), mode='bilinear', align_corners=False).mean(dim=0)
+
+            multi_rater_disc = [torch.as_tensor((self.transform(single_rater) >0.5).float(), dtype=torch.float32) for single_rater in multi_rater_disc]
+            multi_rater_disc = torch.stack(multi_rater_disc, dim=0)
+            mask_disc = F.interpolate(multi_rater_disc, size=(self.mask_size, self.mask_size), mode='bilinear', align_corners=False).mean(dim=0)
+            torch.set_rng_state(state)
+            
+            mask = torch.concat([mask_cup, mask_disc], dim=0)
+
+        if self.prompt == 'box':
+            x_min_cup, x_max_cup, y_min_cup, y_max_cup = random_box(multi_rater_cup)
+            box_cup = [x_min_cup, x_max_cup, y_min_cup, y_max_cup]
+            x_min_disc, x_max_disc, y_min_disc, y_max_disc = random_box(multi_rater_disc)
+            box_disc = [x_min_disc, x_max_disc, y_min_disc, y_max_disc]
+        else:
+            # you may want to get rid of box prompts
+            box_cup = [0, 0, 0, 0]
+            box_disc = [0, 0, 0, 0]
+
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'box': box_cup,
+            'image_meta_dict':image_meta_dict,
+        }

dataset/segrap.py

@@ -0,0 +1,65 @@
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class SegRap(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        self.args = args
+        self.data_path = data_path
+        self.name_list = os.listdir(os.path.join(self.data_path,'SegRap2023_Training_Set_120cases_OneHot_Labels','Task001'))
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+
+    def __getitem__(self, index):
+        # if self.mode == 'Training':
+        #     point_label = random.randint(0, 1)
+        #     inout = random.randint(0, 1)
+        # else:
+        #     inout = 1
+        #     point_label = 1
+        point_label = 1
+        label = 1 # 待分割的类别
+
+        """Get the images"""
+        name = self.name_list[index].split('.')[0]
+        img = nib.load(os.path.join(self.data_path,'SegRap2023_Training_Set_120cases',name,'image.nii.gz')).get_fdata()
+        mask = nib.load(os.path.join(self.data_path,'SegRap2023_Training_Set_120cases_OneHot_Labels','Task001',name+'.nii.gz')).get_fdata()
+
+        img = np.resize(img,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+        mask[mask!=label] = 0
+        mask[mask==label] = 1
+        
+        img = torch.tensor(img).unsqueeze(0)
+        mask = torch.tensor(mask).unsqueeze(0).int()
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask), point_label)
+
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/stare.py

@@ -0,0 +1,75 @@
+import os
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import random_box, random_click
+
+
+class STARE(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        self.data_path = data_path
+        self.name_list = os.listdir(os.path.join(data_path,'masks'))
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+    def __getitem__(self, index):
+        # if self.mode == 'Training':
+        #     point_label = random.randint(0, 1)
+        #     inout = random.randint(0, 1)
+        # else:
+        #     inout = 1
+        #     point_label = 1
+        point_label = 1
+
+        """Get the images"""
+        name = self.name_list[index].split('.')[0]
+
+        img_path = os.path.join(self.data_path, 'images',name+'.ppm')
+        
+        msk_path = os.path.join(self.data_path, 'masks', name+'.ah.ppm')
+
+        img = Image.open(img_path).convert('RGB')
+        mask = Image.open(msk_path).convert('L')
+
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+
+        newsize = (self.img_size, self.img_size)
+        mask = mask.resize(newsize)
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask) / 255, point_label)
+
+        if self.transform:
+            state = torch.get_rng_state()
+            img = self.transform(img)
+            torch.set_rng_state(state)
+
+
+            if self.transform_msk:
+                mask = self.transform_msk(mask).int()
+                
+            # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+            #     mask = 1 - mask
+        name = name.split('/')[-1].split(".jpg")[0]
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }

dataset/toothfairy.py

@@ -0,0 +1,80 @@
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import generate_click_prompt, random_box, random_click
+
+
+class ToothFairy(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+
+        self.args = args
+        self.data_path = os.path.join(data_path,'Dataset')
+        self.name_list = os.listdir(self.data_path)
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+
+    def __getitem__(self, index):
+        point_label = 1
+
+
+        """Get the images"""
+        name = self.name_list[index]
+        img = np.load(os.path.join(self.data_path,name,'data.npy'))
+        mask = np.load(os.path.join(self.data_path,name,'gt_sparse.npy'))
+
+        # if self.mode == 'Training':
+        #     label = 0 if self.label_list[index] == 'benign' else 1
+        # else:
+        #     label = int(self.label_list[index])
+        img = np.transpose(img,(1,2,0))
+        mask = np.transpose(mask,(1,2,0))
+
+        # img = np.resize(mask,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        # mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = np.resize(img,(self.args.image_size, self.args.image_size,img.shape[-1]))
+        mask = np.resize(mask,(self.args.out_size,self.args.out_size,mask.shape[-1]))
+
+        img = torch.tensor(img).unsqueeze(0)
+        mask = torch.tensor(mask).unsqueeze(0)
+        mask = torch.clamp(mask,min=0,max=1).int()
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask), point_label)
+        # if self.transform:
+        #     state = torch.get_rng_state()
+        #     img = self.transform(img)
+        #     torch.set_rng_state(state)
+
+        #     if self.transform_msk:
+        #         mask = self.transform_msk(mask)
+                
+        #     # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+        #     #     mask = 1 - mask
+        name = name.split('/')[-1].split(".jpg")[0]
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }
+

dataset/wbc.py

@@ -0,0 +1,65 @@
+import glob
+import os
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from torch.utils.data import Dataset
+
+from utils import random_box, random_click
+
+
+class WBC(Dataset):
+    def __init__(self, args, data_path , transform = None, transform_msk = None, mode = 'Training',prompt = 'click', plane = False):
+
+        self.data_path = os.path.join(data_path,'Dataset1')
+        self.name_list = glob.glob(self.data_path + "/*.bmp")
+        self.mode = mode
+        self.prompt = prompt
+        self.img_size = args.image_size
+
+        self.transform = transform
+        self.transform_msk = transform_msk
+
+    def __len__(self):
+        return len(self.name_list)
+
+    def __getitem__(self, index):
+        point_label = 1     # available: 1 2
+
+        """Get the images"""
+        name = os.path.basename(self.name_list[index]).split('.')[0]
+
+        img_path = os.path.join(self.data_path, name + '.bmp')
+        msk_path = os.path.join(self.data_path, name + '.png')
+
+        img = Image.open(img_path).convert('RGB')
+        mask = Image.open(msk_path).convert('L')
+
+        mask = np.array(mask) // 127
+        mask[mask!=point_label] = 0
+        mask[mask==point_label] = 255
+
+        if self.prompt == 'click':
+            point_label, pt = random_click(np.array(mask) / 255, point_label)
+
+        if self.transform:
+            state = torch.get_rng_state()
+            img = self.transform(img)
+            torch.set_rng_state(state)
+
+            if self.transform_msk:
+                mask = Image.fromarray(mask)
+                mask = self.transform_msk(mask).int()
+                
+            # if (inout == 0 and point_label == 1) or (inout == 1 and point_label == 0):
+            #     mask = 1 - mask
+        image_meta_dict = {'filename_or_obj':name}
+        return {
+            'image':img,
+            'label': mask,
+            'p_label':point_label,
+            'pt':pt,
+            'image_meta_dict':image_meta_dict,
+        }

environment.yml

@@ -0,0 +1,319 @@
+name: sam_adapt
+channels:
+  - pytorch
+  - conda-forge
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - abseil-cpp=20211102.0=hd4dd3e8_0
+  - absl-py=1.3.0=py310h06a4308_0
+  - aiohttp=3.8.3=py310h5eee18b_0
+  - async-timeout=4.0.2=py310h06a4308_0
+  - attrs=22.1.0=py310h06a4308_0
+  - blas=1.0=mkl
+  - blosc=1.21.3=h6a678d5_0
+  - bottleneck=1.3.5=py310ha9d4c09_0
+  - brotli=1.0.9=h5eee18b_7
+  - brotli-bin=1.0.9=h5eee18b_7
+  - brotlipy=0.7.0=py310h7f8727e_1002
+  - brunsli=0.1=h2531618_0
+  - bzip2=1.0.8=h7b6447c_0
+  - c-ares=1.19.0=h5eee18b_0
+  - ca-certificates=2023.11.17=hbcca054_0
+  - cffi=1.15.1=py310h5eee18b_3
+  - cfitsio=3.470=h5893167_7
+  - charls=2.2.0=h2531618_0
+  - cloudpickle=2.2.1=py310h06a4308_0
+  - comm=0.1.4=pyhd8ed1ab_0
+  - contourpy=1.0.5=py310hdb19cb5_0
+  - cpuonly=2.0=0
+  - cryptography=39.0.1=py310h9ce1e76_0
+  - cudatoolkit=11.3.1=h2bc3f7f_2
+  - cytoolz=0.12.0=py310h5eee18b_0
+  - dask-core=2023.4.1=py310h06a4308_0
+  - dbus=1.13.18=hb2f20db_0
+  - debugpy=1.6.7=py310h6a678d5_0
+  - decorator=5.1.1=pyhd8ed1ab_0
+  - expat=2.4.9=h6a678d5_0
+  - ffmpeg=4.3=hf484d3e_0
+  - fontconfig=2.14.1=h4c34cd2_2
+  - freetype=2.12.1=h4a9f257_0
+  - frozenlist=1.3.3=py310h5eee18b_0
+  - fsspec=2023.4.0=py310h06a4308_0
+  - giflib=5.2.1=h5eee18b_3
+  - glib=2.69.1=he621ea3_2
+  - gmp=6.2.1=h295c915_3
+  - gnutls=3.6.15=he1e5248_0
+  - grpc-cpp=1.48.2=h5bf31a4_0
+  - grpcio=1.48.2=py310h5bf31a4_0
+  - gst-plugins-base=1.14.1=h6a678d5_1
+  - gstreamer=1.14.1=h5eee18b_1
+  - icu=58.2=he6710b0_3
+  - idna=3.4=py310h06a4308_0
+  - imagecodecs=2021.8.26=py310h46e8fbd_2
+  - imageio=2.26.0=py310h06a4308_0
+  - importlib-metadata=6.0.0=py310h06a4308_0
+  - importlib_metadata=6.0.0=hd8ed1ab_0
+  - intel-openmp=2021.4.0=h06a4308_3561
+  - ipykernel=6.26.0=pyhf8b6a83_0
+  - joblib=1.1.1=py310h06a4308_0
+  - jpeg=9e=h5eee18b_1
+  - jupyter_client=8.6.0=pyhd8ed1ab_0
+  - jupyter_core=5.5.0=py310hff52083_0
+  - jxrlib=1.1=h7b6447c_2
+  - kiwisolver=1.4.4=py310h6a678d5_0
+  - krb5=1.19.4=h568e23c_0
+  - lame=3.100=h7b6447c_0
+  - lazy_loader=0.1=py310h06a4308_0
+  - lcms2=2.12=h3be6417_0
+  - ld_impl_linux-64=2.38=h1181459_1
+  - lerc=3.0=h295c915_0
+  - libaec=1.0.4=he6710b0_1
+  - libbrotlicommon=1.0.9=h5eee18b_7
+  - libbrotlidec=1.0.9=h5eee18b_7
+  - libbrotlienc=1.0.9=h5eee18b_7
+  - libclang=14.0.6=default_hc6dbbc7_1
+  - libclang13=14.0.6=default_he11475f_1
+  - libcurl=7.88.1=h91b91d3_0
+  - libdeflate=1.17=h5eee18b_0
+  - libedit=3.1.20221030=h5eee18b_0
+  - libev=4.33=h7f8727e_1
+  - libevent=2.1.12=h8f2d780_0
+  - libffi=3.4.2=h6a678d5_6
+  - libgcc=7.2.0=h69d50b8_2
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgfortran-ng=11.2.0=h00389a5_1
+  - libgfortran5=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libiconv=1.16=h7f8727e_2
+  - libidn2=2.3.2=h7f8727e_0
+  - libllvm14=14.0.6=hdb19cb5_2
+  - libnghttp2=1.46.0=hce63b2e_0
+  - libpng=1.6.39=h5eee18b_0
+  - libpq=12.9=h16c4e8d_3
+  - libprotobuf=3.20.3=he621ea3_0
+  - libsodium=1.0.18=h36c2ea0_1
+  - libssh2=1.10.0=h8f2d780_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libtasn1=4.19.0=h5eee18b_0
+  - libtiff=4.5.0=h6a678d5_2
+  - libunistring=0.9.10=h27cfd23_0
+  - libuuid=1.41.5=h5eee18b_0
+  - libwebp=1.2.4=h11a3e52_1
+  - libwebp-base=1.2.4=h5eee18b_1
+  - libxcb=1.15=h7f8727e_0
+  - libxkbcommon=1.0.1=h5eee18b_1
+  - libxml2=2.10.3=hcbfbd50_0
+  - libxslt=1.1.37=h2085143_0
+  - libzopfli=1.0.3=he6710b0_0
+  - locket=1.0.0=py310h06a4308_0
+  - lz4-c=1.9.4=h6a678d5_0
+  - markdown=3.4.1=py310h06a4308_0
+  - markupsafe=2.1.1=py310h7f8727e_0
+  - matplotlib=3.7.1=py310h06a4308_1
+  - matplotlib-base=3.7.1=py310h1128e8f_1
+  - matplotlib-inline=0.1.6=pyhd8ed1ab_0
+  - mkl=2021.4.0=h06a4308_640
+  - mkl-service=2.4.0=py310h7f8727e_0
+  - mkl_fft=1.3.1=py310hd6ae3a3_0
+  - mkl_random=1.2.2=py310h00e6091_0
+  - monai=1.1.0=pyhd8ed1ab_0
+  - multidict=6.0.2=py310h5eee18b_0
+  - munkres=1.1.4=pyh9f0ad1d_0
+  - ncurses=6.4=h6a678d5_0
+  - nest-asyncio=1.5.8=pyhd8ed1ab_0
+  - nettle=3.7.3=hbbd107a_1
+  - networkx=2.8.4=py310h06a4308_1
+  - nspr=4.33=h295c915_0
+  - nss=3.74=h0370c37_0
+  - numexpr=2.8.4=py310h8879344_0
+  - numpy=1.24.3=py310hd5efca6_0
+  - numpy-base=1.24.3=py310h8e6c178_0
+  - oauthlib=3.2.2=py310h06a4308_0
+  - openh264=2.1.1=h4ff587b_0
+  - openjpeg=2.4.0=h3ad879b_0
+  - openssl=1.1.1w=h7f8727e_0
+  - packaging=23.0=py310h06a4308_0
+  - pandas=1.5.3=py310h1128e8f_0
+  - parso=0.8.3=pyhd8ed1ab_0
+  - pcre=8.45=h295c915_0
+  - pexpect=4.8.0=pyh1a96a4e_2
+  - pickleshare=0.7.5=py_1003
+  - pillow=9.4.0=py310h6a678d5_0
+  - pip=23.0.1=py310h06a4308_0
+  - platformdirs=4.1.0=pyhd8ed1ab_0
+  - ply=3.11=py310h06a4308_0
+  - protobuf=3.20.3=py310h6a678d5_0
+  - ptyprocess=0.7.0=pyhd3deb0d_0
+  - pure_eval=0.2.2=pyhd8ed1ab_0
+  - pycparser=2.21=pyhd8ed1ab_0
+  - pyjwt=2.4.0=py310h06a4308_0
+  - pyopenssl=23.0.0=py310h06a4308_0
+  - pyparsing=3.0.9=py310h06a4308_0
+  - pyqt=5.15.7=py310h6a678d5_1
+  - pysocks=1.7.1=py310h06a4308_0
+  - python=3.10.11=h7a1cb2a_2
+  - python-dateutil=2.8.2=pyhd8ed1ab_0
+  - python_abi=3.10=2_cp310
+  - pytorch-mutex=1.0=cpu
+  - pytz=2022.7=py310h06a4308_0
+  - pyu2f=0.1.5=pyhd8ed1ab_0
+  - pywavelets=1.4.1=py310h5eee18b_0
+  - pyyaml=6.0=py310h5eee18b_1
+  - pyzmq=23.0.0=py310h330234f_0
+  - qt-main=5.15.2=h8373d8f_8
+  - qt-webengine=5.15.9=hbbf29b9_6
+  - qtwebkit=5.212=h3fafdc1_5
+  - re2=2022.04.01=h295c915_0
+  - readline=8.2=h5eee18b_0
+  - requests=2.29.0=py310h06a4308_0
+  - scikit-image=0.20.0=py310h6a678d5_0
+  - scikit-learn=1.2.2=py310h6a678d5_0
+  - scipy=1.10.1=py310hd5efca6_0
+  - seaborn=0.12.2=py310h06a4308_0
+  - setuptools=66.0.0=py310h06a4308_0
+  - sip=6.6.2=py310h6a678d5_0
+  - six=1.16.0=pyh6c4a22f_0
+  - snappy=1.1.9=h295c915_0
+  - sqlite=3.41.2=h5eee18b_0
+  - stack_data=0.6.2=pyhd8ed1ab_0
+  - tensorboard=2.11.0=py310h06a4308_0
+  - tensorboard-data-server=0.6.1=py310h52d8a92_0
+  - tensorboard-plugin-wit=1.8.1=py310h06a4308_0
+  - tk=8.6.12=h1ccaba5_0
+  - toml=0.10.2=pyhd8ed1ab_0
+  - toolz=0.12.0=py310h06a4308_0
+  - torchaudio=0.12.1=py310_cpu
+  - tornado=6.2=py310h5eee18b_0
+  - tqdm=4.65.0=py310h2f386ee_0
+  - typing_extensions=4.5.0=py310h06a4308_0
+  - tzdata=2023c=h04d1e81_0
+  - unicodedata2=14.0.0=py310h5764c6d_1
+  - urllib3=1.26.15=py310h06a4308_0
+  - wheel=0.38.4=py310h06a4308_0
+  - xz=5.4.2=h5eee18b_0
+  - yaml=0.2.5=h7b6447c_0
+  - yarl=1.8.1=py310h5eee18b_0
+  - zeromq=4.3.4=h9c3ff4c_1
+  - zfp=0.5.5=h295c915_6
+  - zipp=3.11.0=py310h06a4308_0
+  - zlib=1.2.13=h5eee18b_0
+  - zstd=1.5.5=hc292b87_0
+  - pip:
+      - aiosignal==1.2.0
+      - alembic==1.10.4
+      - appdirs==1.4.4
+      - astor==0.8.1
+      - asttokens==2.2.1
+      - backcall==0.2.0
+      - beautifulsoup4==4.12.2
+      - blinker==1.6.2
+      - cachetools==4.2.2
+      - certifi==2022.12.7
+      - charset-normalizer==2.0.4
+      - click==8.1.3
+      - cmaes==0.9.1
+      - colorama==0.4.6
+      - colorlog==6.7.0
+      - contextlib2==21.6.0
+      - coverage==6.5.0
+      - coveralls==3.3.1
+      - cucim==23.4.1
+      - cycler==0.11.0
+      - databricks-cli==0.17.7
+      - docker==6.1.1
+      - docopt==0.6.2
+      - einops==0.6.1
+      - entrypoints==0.4
+      - exceptiongroup==1.1.1
+      - executing==1.2.0
+      - filelock==3.12.0
+      - fire==0.5.0
+      - flask==2.3.2
+      - fonttools==4.25.0
+      - future==0.18.3
+      - gdown==4.7.1
+      - gitdb==4.0.10
+      - gitpython==3.1.31
+      - google-auth==2.6.0
+      - google-auth-oauthlib==0.4.4
+      - greenlet==2.0.2
+      - gunicorn==20.1.0
+      - h5py==3.8.0
+      - huggingface-hub==0.14.1
+      - iniconfig==2.0.0
+      - ipython==8.13.1
+      - itk==5.3.0
+      - itk-core==5.3.0
+      - itk-filtering==5.3.0
+      - itk-io==5.3.0
+      - itk-numerics==5.3.0
+      - itk-registration==5.3.0
+      - itk-segmentation==5.3.0
+      - itsdangerous==2.1.2
+      - jedi==0.18.2
+      - jinja2==3.1.2
+      - json-tricks==3.16.1
+      - jsonschema==4.17.3
+      - kornia==0.4.1
+      - lmdb==1.4.1
+      - lucent==0.1.0
+      - mako==1.2.4
+      - mlflow==2.3.1
+      - nibabel==5.1.0
+      - ninja==1.11.1
+      - nni==2.10
+      - nptyping==2.5.0
+      - opencv-python==4.7.0.72
+      - openslide-python==1.1.2
+      - optuna==3.1.1
+      - partd==1.2.0
+      - pluggy==1.0.0
+      - pooch==1.4.0
+      - prettytable==3.7.0
+      - prompt-toolkit==3.0.38
+      - psutil==5.9.5
+      - pyarrow==11.0.0
+      - pyasn1==0.4.8
+      - pyasn1-modules==0.2.8
+      - pydicom==2.3.1
+      - pygments==2.15.1
+      - pynrrd==1.0.0
+      - pyqt5-sip==12.11.0
+      - pyrsistent==0.19.3
+      - pytest==7.3.1
+      - pytest-mock==3.10.0
+      - pythonwebhdfs==0.2.3
+      - pytorch-ignite==0.4.10
+      - querystring-parser==1.2.4
+      - regex==2023.5.5
+      - requests-oauthlib==1.3.0
+      - responses==0.23.1
+      - rsa==4.7.2
+      - safetensors==0.4.1
+      - schema==0.7.5
+      - simplejson==3.19.1
+      - smmap==5.0.0
+      - soupsieve==2.4.1
+      - sqlalchemy==2.0.12
+      - sqlparse==0.4.4
+      - tabulate==0.9.0
+      - tensorboardx==2.2
+      - termcolor==2.3.0
+      - threadpoolctl==2.2.0
+      - tifffile==2021.7.2
+      - timm==0.9.12
+      - tokenizers==0.12.1
+      - tomli==2.0.1
+      - torch==1.12.1+cu113
+      - torch-lucent==0.1.8
+      - torchvision==0.13.1+cu113
+      - traitlets==5.9.0
+      - transformers==4.21.3
+      - typeguard==3.0.2
+      - types-pyyaml==6.0.12.9
+      - wcwidth==0.2.6
+      - websocket-client==1.5.1
+      - websockets==11.0.3
+      - werkzeug==2.3.4