Upload 42 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+dataset/Figure1.png filter=lfs diff=lfs merge=lfs -text

LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright 2024 Hui Lu, Fang Dai, Siqiong Yao, Shanghai jiao tong university
+    
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    
+        http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ResNet_main.sh

@@ -0,0 +1,61 @@
+export MODELNAME="Thyroid_Benign&PTC"
+export ARCH="resnet"
+export IMAGEPATH="./dataset"
+export TRAIN="Benign&PTC_train"
+export VALID="Benign&PTC_valid"
+export TEST="Benign&PTC_test" 
+export BATCH=64
+
+python main_train.py \
+        --modelname $MODELNAME \
+        --architecture $ARCH   \
+        --imagepath $IMAGEPATH   \
+        --train_data $TRAIN   \
+        --valid_data $VALID   \
+        --test_data $TEST  \
+        --learning_rat 0.0005  \
+        --batch_size $BATCH   \
+        --num_epochs 200 \
+        --Class 2
+
+
+
+export MODELNAME="Thyroid_Benign&FTC"
+export ARCH="resnet"
+export IMAGEPATH="./dataset"
+export TRAIN="Benign&FTC_train"
+export VALID="Benign&FTC_valid"
+export TEST="Benign&FTC_test" 
+export BATCH=64
+
+python main_train.py \
+        --modelname $MODELNAME \
+        --architecture $ARCH   \
+        --imagepath $IMAGEPATH   \
+        --train_data $TRAIN   \
+        --valid_data $VALID   \
+        --test_data $TEST  \
+        --learning_rat 0.0005  \
+        --batch_size $BATCH   \
+        --num_epochs 200 \
+        --Class 2
+
+export MODELNAME="Thyroid_Benign&MTC"
+export ARCH="resnet"
+export IMAGEPATH="./dataset"
+export TRAIN="Benign&MTC_train"
+export VALID="Benign&MTC_valid"
+export TEST="Benign&MTC_test" 
+export BATCH=64
+
+python main_train.py \
+        --modelname $MODELNAME \
+        --architecture $ARCH   \
+        --imagepath $IMAGEPATH   \
+        --train_data $TRAIN   \
+        --valid_data $VALID   \
+        --test_data $TEST  \
+        --learning_rat 0.0005  \
+        --batch_size $BATCH   \
+        --num_epochs 200 \
+        --Class 2

Resent/main_train.py

@@ -0,0 +1,113 @@
+import os
+import torch
+from torchvision import models
+import torch.nn as nn
+import torch.optim as optim
+import time
+import copy
+import sys
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics import roc_auc_score
+from scripts.model import train_model
+import scripts.dataset as DATA
+import scripts.config as config
+import argparse
+from PIL import ImageFile
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+def main(args):
+    modelname = args.modelname
+    imagepath = args.imagepath
+    label_num,subgroup_num = config.THYROID()
+    Datasets = DATA.Thyroid_Datasets
+
+    if args.architecture =='resnet':
+        net = models.resnet18(pretrained=True)  
+        features = net.fc.in_features
+        net.fc = nn.Sequential(
+            nn.Linear(features, args.Class))
+
+
+    if os.path.exists('./modelsaved/%s' % modelname) == False:  
+        os.makedirs('./modelsaved/%s' % modelname)
+    if os.path.exists('./result/%s' % modelname) == False:  
+        os.makedirs('./result/%s' % modelname)
+
+
+    data_transforms = config.Transforms(modelname)
+
+    print("%s Initializing Datasets and Dataloaders..." % modelname)
+    
+    transformed_datasets = {}
+    transformed_datasets['train'] = Datasets(
+        path_to_images=imagepath,
+        fold=args.train_data,
+        PRED_LABEL=label_num,
+        transform=data_transforms['train'])
+    transformed_datasets['valid'] = Datasets(
+        path_to_images=imagepath,
+        fold=args.valid_data,
+        PRED_LABEL=label_num,
+        transform=data_transforms['valid'])
+    transformed_datasets['test'] = Datasets(
+        path_to_images=imagepath,
+        fold=args.test_data,
+        PRED_LABEL=label_num,
+        transform=data_transforms['valid'])
+
+    dataloaders = {}
+    dataloaders['train'] = torch.utils.data.DataLoader(
+        transformed_datasets['train'],
+        batch_size=args.batch_size,
+        shuffle=True,
+        num_workers=24)
+    dataloaders['valid'] = torch.utils.data.DataLoader(
+        transformed_datasets['valid'],
+        batch_size=1,
+        shuffle=False,
+        num_workers=24)
+    dataloaders['test'] = torch.utils.data.DataLoader(
+        transformed_datasets['test'],
+        batch_size=1,
+        shuffle=False,
+        num_workers=24)
+
+
+    if args.modelload_path:
+        net.load_state_dict(torch.load('%s' % args.modelload_path , map_location=lambda storage, loc: storage),strict=False)
+   
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    net = net.to(device)
+    optimizer = optim.Adam(filter(lambda p: p.requires_grad, net.parameters()), lr=args.learning_rate, betas=(0.9, 0.99),weight_decay=0.03)
+   
+
+    if args.Class > 2:
+        criterion = nn.BCELoss()
+    else:
+        criterion = nn.CrossEntropyLoss()
+
+    train_model(net,dataloaders, criterion, optimizer, args.num_epochs, modelname, device)
+
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--modelname", type=str, default="Thyroid")
+    parser.add_argument("--architecture", type=str, choices= ["resnet","densnet","efficientnet"], default="resnet")
+    parser.add_argument("--modelload_path", type=str,  default= None)
+    parser.add_argument("--imagepath", type=str,  default="./dataset/")
+    parser.add_argument("--train_data", type=str, default='thyroid_train')
+    parser.add_argument("--valid_data", type=str, default='thyroid_valid')
+    parser.add_argument("--test_data", type=str, default='thyroid_test')
+    parser.add_argument("--learning_rate", type=float, default=0.00005)
+    parser.add_argument("--batch_size", type=int, default=64)
+    parser.add_argument("--num_epochs", type=int, default=100)
+    parser.add_argument("--Class", type=int, default=2)
+    args = parser.parse_args()
+    main(args)
+
+   

Resent/scripts/config.py

@@ -0,0 +1,29 @@
+from torchvision import transforms
+
+THYROID_LABEL = ['Benign', 'Malignant']
+THYROID_SUBGROUP = [['Papillary','Follicular','Medullary']]
+
+
+def THYROID():
+    return (THYROID_LABEL, THYROID_SUBGROUP[0])
+
+
+def Transforms(name):
+    # if name in ["Thyroid"]:
+    data_transforms_ONE = {
+        'valid': transforms.Compose([
+                transforms.CenterCrop(512),
+                transforms.Resize(224),
+                transforms.ToTensor(),
+                transforms.Normalize([.5, .5, .5], [.5, .5, .5])
+            ]),
+        'train': transforms.Compose([
+            transforms.CenterCrop(512),
+            transforms.RandomCrop(256),
+            transforms.Resize(224),
+            transforms.ToTensor(),
+            transforms.Normalize([.5, .5, .5], [.5, .5, .5])
+        ])
+    }
+    return data_transforms_ONE
+        

Resent/scripts/dataset.py

@@ -0,0 +1,80 @@
+import pandas as pd
+import numpy as np
+from torch.utils.data import Dataset
+import os
+from PIL import Image
+
+class Thyroid_Datasets(Dataset):
+    def __init__(
+            self,
+            path_to_images,
+            fold,
+            PRED_LABEL,
+            transform=None,
+            sample=0,
+            finding="any"):
+        self.transform = transform
+        self.path_to_images = path_to_images
+        self.PRED_LABEL = PRED_LABEL
+        self.df = pd.read_csv("%s/CSV/%s.csv" % (path_to_images,fold))
+        print("%s/CSV/%s.csv " % (path_to_images,fold), "num of images:  %s" % len(self.df))
+
+        if(sample > 0 and sample < len(self.df)):
+            self.df = self.df.sample(sample)
+            self.df = self.df.dropna(subset = ['Path'])
+        self.df = self.df.set_index("Path")
+
+
+    def __len__(self):
+        return len(self.df)   
+    
+
+    def __getitem__(self, idx):
+            X = self.df.index[idx]
+            if str(X) is not None:
+                image = Image.open(os.path.join(self.path_to_images,str(X)))
+                image = image.convert('RGB')
+                label = self.df["label".strip()].iloc[idx].astype('int')
+                subg = self.df["subtype".strip()].iloc[idx]
+                if self.transform:
+                    image = self.transform(image)
+
+                return (image, label, subg)
+
+class Multi_Thyroid_Datasets(Dataset):
+    def __init__(
+            self,
+            path_to_images,
+            fold,
+            PRED_LABEL,
+            transform=None,
+            sample=0,
+            finding="any"):
+        self.transform = transform
+        self.path_to_images = path_to_images
+        self.PRED_LABEL = PRED_LABEL
+        self.df = pd.read_csv("%s/CSV/%s.csv" % (path_to_images,fold))
+        print("%s/CSV/%s.csv " % (path_to_images,fold), "num of images:  %s" % len(self.df))
+
+        if(sample > 0 and sample < len(self.df)):
+            self.df = self.df.sample(sample)
+            self.df = self.df.dropna(subset = ['Path'])
+        self.df = self.df.set_index("Path")
+
+
+    def __len__(self):
+        return len(self.df)   
+    
+
+    def __getitem__(self, idx):
+            X = self.df.index[idx]
+            if str(X) is not None:
+                image = Image.open(os.path.join(self.path_to_images,str(X)))
+                image = image.convert('RGB')
+                label = self.df["label".strip()].iloc[idx].astype('int')
+                subg = self.df["subtype".strip()].iloc[idx]
+                if self.transform:
+                    image = self.transform(image)
+
+                return (image, label, subg)
+                return (image, label, subg)

Resent/scripts/model.py

@@ -0,0 +1,152 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import time
+import copy
+import sys
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics import roc_auc_score
+from torch.autograd import Variable
+from scripts.multiAUC import Metric
+import numpy
+from tqdm import tqdm
+from random import sample
+from scripts.plot import bootstrap_auc,result_csv,plotimage
+import pynvml
+pynvml.nvmlInit()
+from prettytable import PrettyTable
+
+
+def train_model(model, dataloaders, criterion, optimizer,num_epochs, modelname, device):
+    global VAL_auc,TEST_auc
+    since = time.time()
+    train_loss_history, valid_loss_history, test_loss_history= [], [], []
+    test_maj_history, test_min_history = [], []
+    train_auc_history, val_auc_history, test_auc_history = [], [], []
+    best_model_wts = copy.deepcopy(model.state_dict())
+    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5)
+    for epoch in range(num_epochs):
+        start = time.time()
+
+        print('{}  Epoch {}/{}  {}'.format('-' * 30, epoch, num_epochs - 1, '-' * 30))
+        for phase in ['train','valid', 'test']:
+            if phase == 'train' and epoch != 0:
+                model.train()
+            else:
+                model.eval()
+            running_loss,running_corrects,prob_all, label_all = [], [], [], []
+            with tqdm(range(len(dataloaders[phase])),desc='%s' % phase, ncols=100) as t:
+                if epoch == 0 :
+                    t.set_postfix(L = 0.000, usedMemory = 0)
+
+                for data in dataloaders[phase]:
+                    inputs, labels, sub = data
+                    print(labels)
+                    inputs = inputs.to(device)
+                    labels = labels.to(device)
+                    optimizer.zero_grad(set_to_none=True) 
+                    with torch.set_grad_enabled(phase == 'train'):
+                        outputs = model(inputs)
+                        loss = criterion(outputs, labels)
+                        _, preds = torch.max(outputs, 1)
+                        if phase == 'train' and epoch != 0:
+                            loss.backward()
+                            optimizer.step()
+                    running_loss.append(loss.item())
+                    running_corrects.append((preds.cpu().detach() == labels.cpu().detach()).numpy())
+
+                    prob_all.extend(outputs[:, 1].cpu().detach().numpy())
+                    label_all.extend(labels.cpu().detach().numpy())
+
+                    """
+                    B:batch 
+                    L:Loss
+                    maj: Maj group AUC
+                    min: Min group AUC
+                    n: NVIDIA Memory used
+                    """   
+                    gpu_device = pynvml.nvmlDeviceGetHandleByIndex(0)
+                    meminfo = pynvml.nvmlDeviceGetMemoryInfo(gpu_device).total
+                    usedMemory = pynvml.nvmlDeviceGetMemoryInfo(gpu_device).used
+                    usedMemory = usedMemory/meminfo              
+                    t.set_postfix(loss = loss.data.item(), usedMemory = usedMemory)  # 
+                    t.update()
+
+
+
+            # num = len(label_all)
+            # auc = roc_auc_score(label_all, prob_all)
+            # epoch_loss = np.mean(running_loss)
+            # label_all = np.array(label_all)
+            # prob_all = np.array(prob_all)
+            # statistics = bootstrap_auc(label_all, prob_all, [0,1,3,4,5])
+            # max_auc = np.max(statistics, axis=1).max()
+            # min_auc = np.min(statistics, axis=1).max()
+            # print('{} --> Num: {} Loss: {:.4f}  AUROC: {:.4f} ({:.2f} ~ {:.2f})'.format(
+            #     phase, num, epoch_loss, auc, min_auc, max_auc ))
+            if modelname =="Thyroid_PF":
+                try:
+                    data_auc = roc_auc_score(Label,Output)
+                    Data_auc_maj = roc_auc_score(Label_maj, Output_maj)
+                    Data_auc_min = roc_auc_score(Label_min, Output_min)
+                except:
+                    data_auc = roc_auc_score(Label,Output)
+                    Data_auc_maj = 0
+                    Data_auc_min = 0
+                epoch_loss = running_loss / Batch
+                statistics = bootstrap_auc(Label, Output, [0,1,2,3,4])
+                max_auc = np.max(statistics, axis=1).max()
+                min_auc = np.min(statistics, axis=1).max()
+                if G == [] and phase == "train":
+                    G1.append(0)
+                elif phase == "train":
+                    G1.append(sum(G)/len(G))
+                print('{} --> Num: {} Loss: {:.4f}  Gamma: {:.4f} AUROC: {:.4f} ({:.2f} ~ {:.2f}) (Maj {:.4f}, Min {:.4f})'.format(
+                phase, len(outputs_out), epoch_loss, G1[-1], data_auc, min_auc, max_auc, Data_auc_maj, Data_auc_min))
+
+            else:
+                myMetic = Metric(Output,Label)
+                data_auc,auc = myMetic.auROC() 
+                epoch_loss = running_loss / Batch
+                statistics = bootstrap_auc(Label, Output, [0,1,2,3,4])
+                max_auc = np.max(statistics, axis=1).max()
+                min_auc = np.min(statistics, axis=1).max()
+                if G == [] and phase == "train":
+                    G1.append(0)
+                elif phase == "train":
+                    G1.append(sum(G)/len(G))
+                print('{} --> Num: {} Loss: {:.4f}  AUROC: {:.4f} ({:.2f} ~ {:.2f}) (Maj {:.4f}, Min {:.4f})'.format(
+                        phase, len(outputs_out), epoch_loss, data_auc, min_auc, max_auc, data_auc_maj,data_auc_min))
+
+            if phase == 'train':
+                train_loss_history.append(epoch_loss)
+                train_auc_history.append(auc)
+
+            if phase == 'valid':
+                valid_loss_history.append(epoch_loss)
+                val_auc_history.append(auc)
+
+            if phase == 'test':
+                test_loss_history.append(epoch_loss)
+                test_auc_history.append(auc)
+      
+            if phase == 'valid' and train_auc_history[-1] >= 0.9:
+                if val_auc_history[-1] >= max(val_auc_history) or test_auc_history[-1] >= max(test_auc_history):
+                    print("In epoch %d, better AUC(%.3f) and save model. " % (epoch, float(val_auc_history[-1])))
+                    PATH = '/export/home/daifang/Diffusion/Resnet/modelsaved/%s/e%d_%s_V%.3fT%.3f.pth' % (modelname,epoch,modelname,val_auc_history[-1],test_auc_history[-1])
+                    torch.save(model.state_dict(),PATH)
+    
+        print("learning rate = %.6f     time: %.1f sec" % (optimizer.param_groups[-1]['lr'], time.time() - start))
+        if epoch != 0:
+            scheduler.step()
+        print()
+
+        plotimage(train_auc_history, val_auc_history, test_auc_history,"AUC", modelname)        
+        plotimage(train_loss_history, valid_loss_history, test_loss_history,"Loss", modelname)
+        result_csv( train_auc_history, val_auc_history, test_auc_history, modelname)
+        
+    time_elapsed = time.time() - since
+    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))
+    model.load_state_dict(best_model_wts)

Resent/scripts/multiAUC.py

@@ -0,0 +1,138 @@
+import sklearn
+import numpy as np
+from scipy.sparse import csr_matrix
+from scipy.sparse.csgraph import laplacian
+from scipy.sparse.linalg import eigs
+from sklearn.metrics import accuracy_score
+from sklearn.metrics import f1_score
+from sklearn.metrics import hamming_loss
+from sklearn.metrics import roc_auc_score
+import pandas as pd
+from random import sample
+
+# np.set_printoptions(threshold='nan')
+class Metric(object):
+    def __init__(self,output,label):
+        self.output = output   #prediction label matric
+        self.label = label    #true  label matric
+ 
+    def accuracy_subset(self,threash=0.5):
+        y_pred =self.output
+        y_true = self.label
+        y_pred=np.where(y_pred>threash,1,0)
+        accuracy=accuracy_score(y_true,y_pred)
+        return accuracy
+    
+    def accuracy(self,threash=0.5):
+        y_pred =self.output
+        y_true = self.label      
+        y_pred=np.where(y_pred>threash,1,0)
+        accuracy=sklearn.metrics.accuracy_score(y_true, y_pred, normalize=True, sample_weight=None)
+        return accuracy
+    
+    def accuracy_multiclass(self):
+        y_pred =self.output
+        y_true = self.label     
+        accuracy=accuracy_score(np.argmax(y_pred,1),np.argmax(y_true,1))
+        return accuracy
+    
+    def micfscore(self,threash=0.5,type='micro'):
+        y_pred =self.output
+        y_true = self.label
+        y_pred=np.where(y_pred>threash,1,0)
+        return f1_score(y_pred,y_true,average=type)
+
+    def macfscore(self,threash=0.5,type='macro'):
+        y_pred =self.output
+        y_true = self.label
+        y_pred=np.where(y_pred>threash,1,0)
+        return f1_score(y_pred,y_true,average=type)
+    
+    def hamming_distance(self,threash=0.5):
+        y_pred =self.output
+        y_true = self.label
+        y_pred=np.where(y_pred>threash,1,0)
+        return hamming_loss(y_true,y_pred)
+    
+    def fscore_class(self,type='micro'):
+        y_pred =self.output
+        y_true = self.label
+        return f1_score(np.argmax(y_pred,1),np.argmax(y_true,1),average=type)
+    
+    def auROC(self):
+        y_pred =self.output
+        y_true = self.label
+        row,col = y_true.shape
+        temp = []
+        ROC = 0
+        for i in range(col):
+            try:
+                ROC = roc_auc_score(y_true[:,i], y_pred[:,i], average='micro', sample_weight=None)
+            except:
+                ROC == 0.5  
+            temp.append(ROC)
+        for i in range(col):
+            ROC += float(temp[i])
+        return ROC/(col+1),temp
+    
+    def MacroAUC(self):
+        y_pred =self.output #num_instance*num_label
+        y_true = self.label #num_instance*num_label 
+        num_instance,num_class =  y_pred.shape
+        count = np.zeros((num_class,1))   # store the number of postive instance'score>negative instance'score
+        num_P_instance =  np.zeros((num_class,1)) #number of positive instance for every label      
+        num_N_instance =  np.zeros((num_class,1)) 
+        auc = np.zeros((num_class,1))  # for each label
+        count_valid_label = 0
+        for  i in range(num_class): 
+            num_P_instance[i,0] = sum(y_true[:,i] == 1) #label,,test_target
+            num_N_instance[i,0] = num_instance - num_P_instance[i,0]
+            # exclude the label on which all instances are positive or negative,
+            # leading to num_P_instance(i,1) or num_N_instance(i,1) is zero
+            if num_P_instance[i,0] == 0 or num_N_instance[i,0] == 0:
+                auc[i,0] = 0
+                count_valid_label = count_valid_label + 1
+            else:
+                temp_P_Outputs = np.zeros((int(num_P_instance[i,0]), num_class))
+                temp_N_Outputs = np.zeros((int(num_N_instance[i,0]), num_class))
+                #
+                temp_P_Outputs[:,i] = y_pred[y_true[:,i]==1,i]
+                temp_N_Outputs[:,i] = y_pred[y_true[:,i]==0,i]    
+                for m in range(int(num_P_instance[i,0])):
+                    for n in range(int(num_N_instance[i,0])):
+                        if(temp_P_Outputs[m,i] > temp_N_Outputs[n,i] ):
+                            count[i,0] = count[i,0] + 1
+                        elif(temp_P_Outputs[m,i] == temp_N_Outputs[n,i]):
+                            count[i,0] = count[i,0] + 0.5
+                
+                auc[i,0] = count[i,0]/(num_P_instance[i,0]*num_N_instance[i,0])  
+        macroAUC1 = sum(auc)/(num_class-count_valid_label)
+        return  float(macroAUC1), auc
+
+
+def bootstrap_auc(label, output, classes, bootstraps=5, fold_size=1000):
+    statistics = np.zeros((len(classes), bootstraps))
+    for c in range(len(classes)):
+        for i in range(bootstraps):
+            L=[]
+            for k in range(len(label)):
+                L.append([output[k],label[k]])
+            if fold_size <= len(L):
+                X = sample(L, fold_size)
+            else:
+                fold_size == len(L)
+                X = sample(L, fold_size)
+            for b in range(len(X)):
+                if b ==0:
+                    Output =  np.array([X[b][0]])
+                    Label =  np.array([X[b][1]])
+                Output = np.concatenate((Output, np.array([X[b][0]])),axis=0)
+                Label = np.concatenate((Label, np.array([X[b][1]])),axis=0)
+                
+            myMetic = Metric(Output,Label)
+            AUROC1, auc = myMetic.auROC()
+            statistics[c][i] = AUROC1
+    return statistics
+    
+
+

Resent/testmodel.py

@@ -0,0 +1,139 @@
+import os
+import torch
+from torch.utils.data import DataLoader
+from torchvision import models, datasets, transforms
+import torch.nn as nn
+import torch.optim as optim
+import time
+import copy
+import sys
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.metrics import roc_auc_score
+from pandas.core.frame import DataFrame
+from sklearn.calibration import calibration_curve
+import warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+def softmax(x):
+    exp_x = np.exp(x)  # 为了数值稳定性，减去最大值
+    return exp_x / np.sum(exp_x)
+
+def bootstrap_auc(y, pred, classes, bootstraps=10, fold_size=500):
+    statistics = np.zeros((len(classes), bootstraps))
+
+    for c in range(len(classes)):
+        df = pd.DataFrame(columns=['y', 'pred'])
+        # df.
+        df.loc[:, 'y'] = y
+        df.loc[:, 'pred'] = pred
+        df_pos = df[df.y == 1]
+        df_neg = df[df.y == 0]
+        prevalence = len(df_pos) / len(df)
+        for i in range(bootstraps):
+            pos_sample = df_pos.sample(n=int(fold_size * prevalence), replace=True)
+            neg_sample = df_neg.sample(n=int(fold_size * (1 - prevalence)), replace=True)
+            y_sample = np.concatenate([pos_sample.y.values, neg_sample.y.values])
+            pred_sample = np.concatenate([pos_sample.pred.values, neg_sample.pred.values])
+            score = roc_auc_score(y_sample, pred_sample)
+            statistics[c][i] = score
+    return statistics
+
+
+
+if __name__ == '__main__':
+    batch_size = 128
+    flag = torch.cuda.is_available()
+    if flag:
+        print("CUDA可使用")
+    else:
+        print("CUDA不可用")
+    ngpu = 1
+    # Decide which device we want to run on
+    device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")
+    print("驱动为：", device)
+    net = models.resnet18(pretrained=False)
+    # 导入预训练的模型
+    features = net.fc.in_features
+    net.fc = nn.Sequential(
+        nn.Linear(features, 2),
+    )
+    modelname = "Model_all"
+
+    CSV, Mean_auc, Max_auc, Min_auc, Name_auc, Test_auc = [], [], [], [], [], []
+    net.load_state_dict(torch.load("./modelsaved/A_goodA0.87_epoch15.pth",
+                                   map_location=lambda storage, loc: storage), strict=False)
+
+    file_name = "test"
+    data_transforms = {
+        'test': transforms.Compose([
+            transforms.Resize(224),
+            transforms.ToTensor(),
+            transforms.Normalize([.5, .5, .5], [.5, .5, .5])
+        ]),
+    }
+
+    print("%s Initializing Datasets and Dataloaders..." % file_name)
+
+    test_datasets = datasets.ImageFolder("/export/home/daifang/Diffusion/Resnet/dataset/figure/PTC", transform=data_transforms['test'])
+    num_workers = 20
+    dataloaders_dict = {
+        'test': DataLoader(test_datasets, batch_size=64, shuffle=True, num_workers=num_workers)}
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    net = net.to(device)
+
+    for phase in ['test']:
+        net.eval()
+        running_loss = 0.0
+        running_corrects = 0
+        prob_all, label_all, output_list = [], [], [[], []]
+        outputs = []
+        for inputs, labels in dataloaders_dict[phase]:
+            inputs = inputs.to(device)
+            labels = labels.to(device)
+            outputs = net(inputs)
+
+            output_list[0].extend(outputs.tolist())
+
+            output_list[1].extend(labels.tolist())
+            _, preds = torch.max(outputs, 1)
+            running_corrects += torch.sum(preds == labels.data)
+            prob_all.extend(outputs[:, 1].cpu().detach().numpy())
+            label_all.extend(labels.cpu().detach().numpy())
+        data_auc = roc_auc_score(label_all, prob_all)
+        epoch_acc = running_corrects.double() / len(dataloaders_dict[phase].dataset)
+        print(prob_all)
+        print(label_all)
+        scores = np.array(prob_all)
+        y = np.array(label_all)
+        # print(scores)
+        # print(y)
+
+        prob_true, prob_pred = calibration_curve(y, softmax(scores), n_bins=10)
+        print(prob_true)
+        print(prob_pred)
+        # 绘制校准曲线
+        plt.figure(figsize=(10, 10))
+        plt.plot(prob_pred, prob_true, marker='o', label='Calibration Curve')
+        plt.plot([0, 1], [0, 1], linestyle='--', color='gray', label='Perfectly Calibrated')
+        plt.xlabel('Predicted Probability')
+        plt.ylabel('True Probability')
+        plt.title('Calibration Curve')
+        plt.legend()
+        plt.grid()
+        plt.savefig("calibration_curve.png", dpi=300, bbox_inches='tight')
+        statistics = bootstrap_auc(y, scores, [0, 1, 2, 3, 4])
+
+        mean_auc = np.mean(statistics, axis=1).max()
+        max_auc = np.max(statistics, axis=1).max()
+        min_auc = np.min(statistics, axis=1).max()
+
+        Name_auc.append(file_name + phase)
+        Test_auc.append(data_auc)
+        Mean_auc.append(mean_auc)
+        Max_auc.append(max_auc)
+        Min_auc.append(min_auc)
+        print('Testing: {}  Acc: {:.4f}   AUC: {:.4f} ({:.4f} - {:.4f}) '.format(phase, epoch_acc, data_auc,min_auc, max_auc))

Tiger-Coarse.sh

@@ -0,0 +1,23 @@
+export MODEL_NAME="../sdmodel/v2-1" # In this study, Stable diffusion v2-1 is used as the pre-training model
+export DATASET_NAME="../dataset/thyroid_image/training_data"
+export PROMPT="ultrasound of papillary thyroid carcinoma, malignancy, wider-than-tall, shape" # Prompt to verify the effect of model generation
+
+CUDA_VISIBLE_DEVICES='0,1,2,3,4,5,6,7' accelerate launch --multi_gpu --num_processes=8 Tiger Model/Coarse-Training.py \
+    --pretrained_model_name_or_path=$MODEL_NAME \
+    --dataset_name=$DATASET_NAME \
+    --caption_column="text" \
+    --resolution=512 \
+    --random_flip \
+    --gradient_accumulation_steps=4 \
+    --train_batch_size=24 \
+    --num_train_epochs=4000 \
+    --checkpointing_steps=1000 \
+    --learning_rate=1e-04 \
+    --lr_scheduler="constant" \
+    --lr_warmup_steps=500 \
+    --seed=2024 \
+    --output_dir="./modelsaved/Tiger-Corase" \ # Model saving
+    --validation_epochs=1 \
+    --validation_prompt=$PROMPT
+    --report_to="wandb"  
+# For the description of parameter meanings, see Appendix

Tiger-Fine.sh

@@ -0,0 +1,21 @@
+export MODEL_DIR="../modelsaved/Tiger-Corase/checkpoint-xxx"
+export OUTPUT_DIR="/modelsaved/Tiger-Fine"
+export DATASET="../dataset/training data/init_image"
+
+CUDA_VISIBLE_DEVICES='0,1,2' accelerate launch --multi_gpu --num_processes=3 Tiger Model/Fine-Training.py \
+     --pretrained_model_name_or_path=$MODEL_DIR \
+     --output_dir=$OUTPUT_DIR \
+     --dataset_name=$DATASET \
+     --resolution=512 \
+     --seed=2023 \
+     --learning_rate=1e-5 \
+     --gradient_accumulation_steps=4 \
+     --checkpointing_steps=200 \
+     --max_train_steps=100000000000 \
+     --train_batch_size=24 \ 
+     --image_column="image" \
+     --caption_column_nd="text_nd" --caption_column_bg="text_bd" \
+     --conditioning_nd_column="condition_FG" --conditioning_bg_column="condition_BG" \
+     --validation_image "../valid_Figure.png" \
+     --validation_prompt "malignant papillary solid ..." \
+     --validation_steps=500

dataset/Resnet training data/PTC/test/0/0.txt

@@ -0,0 +1 @@
+

dataset/Resnet training data/PTC/test/1/1.txt

@@ -0,0 +1 @@
+

dataset/Resnet training data/PTC/train/0/fi.txt

@@ -0,0 +1 @@
+

dataset/Resnet training data/PTC/train/1/figure1.txt

@@ -0,0 +1 @@
+

dataset/Resnet training data/PTC/valid/0/0.txt

@@ -0,0 +1 @@
+

dataset/Resnet training data/PTC/valid/1/1.txt

@@ -0,0 +1 @@
+

dataset/training data/init_image/metadata.jsonl

@@ -0,0 +1,7 @@
+{"file_name": "635348002413906250.png", "condition_nd": "training data/condition_FG/635348002413906250.png", "condition_bg": "training data/condition_BG/635348002413906250.png", "text_nd": "malignant, papillary nodule, irregular, solid, heterogeneous, hypoechoic, unclear, regular, heterogeneous, wider-than-tall, large", "text_bg": "sonogram longitudinal plane, less definition, less detail, high bright"}
+{"file_name": "634878812500937500.png", "condition_nd": "training data/condition_FG/634878812500937500.png", "condition_bg": "training data/condition_BG/634878812500937500.pngg", "text_nd": "papillary nodule, irregular, solid, heterogeneous, hypoechoic, irregular, unclear, wider-than-tall, large", "text_bg": "sonogram longitudinal plane, more definition, more detail, bright"}
+{"file_name": "635501726176562500.jpg", "condition_nd": "training data/condition_FG/635501726176562500.jpg", "condition_bg": "training data/condition_BG/635501726176562500.jpg", "text_nd": "malignant, medullary nodule,", "text_bg": "sonogram transverse middle, less definition, less detail, bright"}
+{"file_name": "20191101_094946_8.png", "condition_nd": "training data/condition_FG/20191101_094946_8.png", "condition_bg": "training data/condition_BG/20191101_094946_8.png", "text_nd": "papillary", "text_bg": "sonogram longitudinal plane, less definition, less detail, bright"}
+{"file_name": "20191101_111608_16.png", "condition_nd": "training data/condition_FG/20191101_111608_16.png", "condition_bg": "training data/condition_BG/20191101_111608_16.png", "text_nd": "follicular", "text_bg": "sonogram longitudinal plane, definition, less detail, bright"}
+{"file_name": "20191101_111809_22.png", "condition_nd": "training data/condition_FG/20191101_111809_22.png", "condition_bg": "training data/condition_BG/20191101_111809_22.png", "text_nd": "follicular", "text_bg": "sonogram longitudinal plane, less definition, less detail, high bright"}
+{"file_name": "20191104_140920_45.png", "condition_nd": "training data/condition_FG/20191104_140920_45.png", "condition_bg": "training data/condition_BG/20191104_140920_45.png", "text_nd": "papillary", "text_bg": "sonogram transverse middle, less definition, less detail, high bright"}

model/pretrain/thyroid_stable_diffusion/1.txt

@@ -0,0 +1 @@
+

modelsaved/readme.md

@@ -0,0 +1,16 @@
+# Modelsaved file
+The code is set to save the model after a certain period of time, and the model saves the following:
+```sh
+Steps:   0%|                                                                 | 1000/100000000000 [17:11<27774189:14:01,  1.00it/s, los
+- INFO - accelerate.accelerator - Saving current state to ../modelsaved/OUTPUT_DIR/checkpoint-1000
+Configuration saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/controlnet_nd/config.json
+Model weights saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/controlnet_nd/diffusion_pytorch_model.safetensors
+- INFO - accelerate.checkpointing - Model weights saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/pytorch_model.bin
+- INFO - accelerate.checkpointing - Optimizer state saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/optimizer.bin
+- INFO - accelerate.checkpointing - Optimizer state saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/optimizer_1.bin
+- INFO - accelerate.checkpointing - Scheduler state saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/scheduler.bin
+- INFO - accelerate.checkpointing - Sampler state for dataloader 0 saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/sampler.bin
+- INFO - accelerate.checkpointing - Random states saved in ../modelsaved/OUTPUT_DIR/checkpoint-1000/random_states_0.pkl
+- INFO - __main__ - Saved state to ../modelsaved/OUTPUT_DIR/checkpoint-1000
+... ...
+````

requirements.txt

@@ -0,0 +1,367 @@
+# This file may be used to create an environment using:
+# $ conda create --name <env> --file <this file>
+# platform: linux-64
+_libgcc_mutex=0.1=main
+_openmp_mutex=5.1=1_gnu
+absl-py=1.4.0=pypi_0
+accelerate=0.24.1=pypi_0
+addict=2.4.0=pypi_0
+aiohttp=3.8.4=pypi_0
+aiosignal=1.3.1=pypi_0
+anyio=3.7.1=pypi_0
+appdirs=1.4.4=pypi_0
+argon2-cffi=21.3.0=pypi_0
+argon2-cffi-bindings=21.2.0=pypi_0
+arrow=1.2.3=pypi_0
+asttokens=2.2.1=pypi_0
+astunparse=1.6.3=pypi_0
+async-lru=2.0.3=pypi_0
+async-timeout=4.0.2=pypi_0
+attrs=22.2.0=pypi_0
+babel=2.12.1=pypi_0
+backcall=0.2.0=pypi_0
+beautifulsoup4=4.12.2=pypi_0
+blas=1.0=mkl
+bleach=6.0.0=pypi_0
+boltons=23.0.0=py38h06a4308_0
+brotlipy=0.7.0=py38h27cfd23_1003
+bzip2=1.0.8=h7b6447c_0
+ca-certificates=2023.01.10=h06a4308_0
+cachetools=5.3.0=pypi_0
+certifi=2022.12.7=py38h06a4308_0
+cffi=1.15.1=py38h5eee18b_3
+charset-normalizer=2.0.4=pyhd3eb1b0_0
+click=8.1.3=pypi_0
+clip-interrogator=0.6.0=pypi_0
+cmake=3.26.3=pypi_0
+colorama=0.4.6=pypi_0
+comm=0.1.3=pypi_0
+conda=23.3.1=py38h06a4308_0
+conda-package-handling=2.0.2=py38h06a4308_0
+conda-package-streaming=0.7.0=py38h06a4308_0
+contourpy=1.0.7=pypi_0
+cryptography=39.0.1=py38h9ce1e76_0
+cuda=11.6.1=0
+cuda-cccl=11.6.55=hf6102b2_0
+cuda-command-line-tools=11.6.2=0
+cuda-compiler=11.6.2=0
+cuda-cudart=11.6.55=he381448_0
+cuda-cudart-dev=11.6.55=h42ad0f4_0
+cuda-cuobjdump=11.6.124=h2eeebcb_0
+cuda-cupti=11.6.124=h86345e5_0
+cuda-cuxxfilt=11.6.124=hecbf4f6_0
+cuda-driver-dev=11.6.55=0
+cuda-gdb=12.1.55=0
+cuda-libraries=11.6.1=0
+cuda-libraries-dev=11.6.1=0
+cuda-memcheck=11.8.86=0
+cuda-nsight=12.1.55=0
+cuda-nsight-compute=12.1.0=0
+cuda-nvcc=11.6.124=hbba6d2d_0
+cuda-nvdisasm=12.1.55=0
+cuda-nvml-dev=11.6.55=haa9ef22_0
+cuda-nvprof=12.1.55=0
+cuda-nvprune=11.6.124=he22ec0a_0
+cuda-nvrtc=11.6.124=h020bade_0
+cuda-nvrtc-dev=11.6.124=h249d397_0
+cuda-nvtx=11.6.124=h0630a44_0
+cuda-nvvp=12.1.55=0
+cuda-runtime=11.6.1=0
+cuda-samples=11.6.101=h8efea70_0
+cuda-sanitizer-api=12.1.55=0
+cuda-toolkit=11.6.1=0
+cuda-tools=11.6.1=0
+cuda-visual-tools=11.6.1=0
+cycler=0.11.0=pypi_0
+datasets=2.12.0=pypi_0
+debugpy=1.6.7=pypi_0
+decorator=5.1.1=pypi_0
+defusedxml=0.7.1=pypi_0
+diffusers=0.19.0.dev0=pypi_0
+dill=0.3.6=pypi_0
+docker-pycreds=0.4.0=pypi_0
+exceptiongroup=1.1.2=pypi_0
+executing=1.2.0=pypi_0
+fastjsonschema=2.18.0=pypi_0
+ffmpeg=4.3=hf484d3e_0
+filelock=3.10.7=pypi_0
+fire=0.5.0=pypi_0
+flatbuffers=23.5.9=pypi_0
+flit-core=3.8.0=py38h06a4308_0
+fonttools=4.39.3=pypi_0
+fqdn=1.5.1=pypi_0
+freetype=2.12.1=h4a9f257_0
+frozenlist=1.3.3=pypi_0
+fsspec=2023.3.0=pypi_0
+ftfy=6.1.1=pypi_0
+gast=0.4.0=pypi_0
+gds-tools=1.6.0.25=0
+giflib=5.2.1=h5eee18b_3
+giotto-ph=0.2.4=pypi_0
+giotto-tda=0.6.2=pypi_0
+gitdb=4.0.10=pypi_0
+gitpython=3.1.31=pypi_0
+gmp=6.2.1=h295c915_3
+gnutls=3.6.15=he1e5248_0
+google-auth=2.16.2=pypi_0
+google-auth-oauthlib=1.0.0=pypi_0
+google-pasta=0.2.0=pypi_0
+grpcio=1.51.3=pypi_0
+h5py=3.8.0=pypi_0
+huggingface-hub=0.16.4=pypi_0
+idna=3.4=py38h06a4308_0
+igraph=0.11.5=pypi_0
+imageio=2.31.1=pypi_0
+importlib-metadata=6.1.0=pypi_0
+importlib-resources=5.12.0=pypi_0
+imtools=2.0.1=pypi_0
+intel-openmp=2021.4.0=h06a4308_3561
+ipykernel=6.24.0=pypi_0
+ipython=8.12.2=pypi_0
+ipython-genutils=0.2.0=pypi_0
+ipywidgets=8.0.7=pypi_0
+isoduration=20.11.0=pypi_0
+jax=0.4.9=pypi_0
+jedi=0.18.2=pypi_0
+jinja2=3.1.2=pypi_0
+joblib=1.2.0=pypi_0
+jpeg=9e=h5eee18b_1
+json5=0.9.14=pypi_0
+jsonlines=3.1.0=pypi_0
+jsonpatch=1.32=pyhd3eb1b0_0
+jsonpointer=2.1=pyhd3eb1b0_0
+jsonschema=4.18.4=pypi_0
+jsonschema-specifications=2023.7.1=pypi_0
+jupyter=1.0.0=pypi_0
+jupyter-client=8.3.0=pypi_0
+jupyter-console=6.6.3=pypi_0
+jupyter-core=5.3.1=pypi_0
+jupyter-events=0.6.3=pypi_0
+jupyter-lsp=2.2.0=pypi_0
+jupyter-server=2.7.0=pypi_0
+jupyter-server-terminals=0.4.4=pypi_0
+jupyterlab=4.0.3=pypi_0
+jupyterlab-pygments=0.2.2=pypi_0
+jupyterlab-server=2.24.0=pypi_0
+jupyterlab-widgets=3.0.8=pypi_0
+keras=2.12.0=pypi_0
+kiwisolver=1.4.4=pypi_0
+lame=3.100=h7b6447c_0
+lazy-loader=0.2=pypi_0
+lcms2=2.12=h3be6417_0
+ld_impl_linux-64=2.38=h1181459_1
+lerc=3.0=h295c915_0
+libclang=16.0.0=pypi_0
+libcublas=11.9.2.110=h5e84587_0
+libcublas-dev=11.9.2.110=h5c901ab_0
+libcufft=10.7.1.112=hf425ae0_0
+libcufft-dev=10.7.1.112=ha5ce4c0_0
+libcufile=1.6.0.25=0
+libcufile-dev=1.6.0.25=0
+libcurand=10.3.2.56=0
+libcurand-dev=10.3.2.56=0
+libcusolver=11.3.4.124=h33c3c4e_0
+libcusparse=11.7.2.124=h7538f96_0
+libcusparse-dev=11.7.2.124=hbbe9722_0
+libdeflate=1.17=h5eee18b_0
+libffi=3.4.2=h6a678d5_6
+libgcc-ng=11.2.0=h1234567_1
+libgomp=11.2.0=h1234567_1
+libiconv=1.16=h7f8727e_2
+libidn2=2.3.2=h7f8727e_0
+libnpp=11.6.3.124=hd2722f0_0
+libnpp-dev=11.6.3.124=h3c42840_0
+libnvjpeg=11.6.2.124=hd473ad6_0
+libnvjpeg-dev=11.6.2.124=hb5906b9_0
+libpng=1.6.39=h5eee18b_0
+libstdcxx-ng=11.2.0=h1234567_1
+libtasn1=4.16.0=h27cfd23_0
+libtiff=4.5.0=h6a678d5_2
+libunistring=0.9.10=h27cfd23_0
+libwebp=1.2.4=h11a3e52_1
+libwebp-base=1.2.4=h5eee18b_1
+lit=16.0.3=pypi_0
+lz4-c=1.9.4=h6a678d5_0
+markdown=3.4.1=pypi_0
+markdown-it-py=2.2.0=pypi_0
+markupsafe=2.1.2=pypi_0
+matplotlib=3.7.1=pypi_0
+matplotlib-inline=0.1.6=pypi_0
+mdurl=0.1.2=pypi_0
+medmnist=2.2.2=pypi_0
+mistune=3.0.1=pypi_0
+mkl=2021.4.0=h06a4308_640
+mkl-service=2.4.0=py38h7f8727e_0
+mkl_fft=1.3.1=py38hd3c417c_0
+mkl_random=1.2.2=py38h51133e4_0
+ml-dtypes=0.1.0=pypi_0
+mmengine=0.7.3=pypi_0
+model-index=0.1.11=pypi_0
+mpmath=1.3.0=pypi_0
+multidict=6.0.4=pypi_0
+multiprocess=0.70.14=pypi_0
+mypy-extensions=1.0.0=pypi_0
+nbclient=0.8.0=pypi_0
+nbconvert=7.7.2=pypi_0
+nbformat=5.9.1=pypi_0
+ncurses=6.4=h6a678d5_0
+nest-asyncio=1.5.6=pypi_0
+nettle=3.7.3=hbbd107a_1
+networkx=3.1=pypi_0
+notebook=7.0.0=pypi_0
+notebook-shim=0.2.3=pypi_0
+nsight-compute=2023.1.0.15=0
+numpy=1.23.5=py38h14f4228_0
+numpy-base=1.23.5=py38h31eccc5_0
+nvidia-cublas-cu11=11.10.3.66=pypi_0
+nvidia-cuda-cupti-cu11=11.7.101=pypi_0
+nvidia-cuda-nvrtc-cu11=11.7.99=pypi_0
+nvidia-cuda-runtime-cu11=11.7.99=pypi_0
+nvidia-cudnn-cu11=8.5.0.96=pypi_0
+nvidia-cufft-cu11=10.9.0.58=pypi_0
+nvidia-curand-cu11=10.2.10.91=pypi_0
+nvidia-cusolver-cu11=11.4.0.1=pypi_0
+nvidia-cusparse-cu11=11.7.4.91=pypi_0
+nvidia-nccl-cu11=2.14.3=pypi_0
+nvidia-nvtx-cu11=11.7.91=pypi_0
+oauthlib=3.2.2=pypi_0
+open-clip-torch=2.20.0=pypi_0
+opencv-python=4.7.0.72=pypi_0
+openh264=2.1.1=h4ff587b_0
+openmim=0.3.7=pypi_0
+openssl=1.1.1t=h7f8727e_0
+opt-einsum=3.3.0=pypi_0
+ordered-set=4.1.0=pypi_0
+overrides=7.3.1=pypi_0
+packaging=23.0=pypi_0
+pandas=1.5.3=pypi_0
+pandocfilters=1.5.0=pypi_0
+parso=0.8.3=pypi_0
+pathtools=0.1.2=pypi_0
+pexpect=4.8.0=pypi_0
+pickleshare=0.7.5=pypi_0
+pillow=9.4.0=pypi_0
+pip=23.0.1=py38h06a4308_0
+pkgutil-resolve-name=1.3.10=pypi_0
+platformdirs=3.9.1=pypi_0
+plotly=5.22.0=pypi_0
+pluggy=1.0.0=py38h06a4308_1
+prdc=0.2=pypi_0
+prometheus-client=0.17.1=pypi_0
+prompt-toolkit=3.0.38=pypi_0
+protobuf=3.20.3=pypi_0
+psutil=5.9.4=pypi_0
+ptyprocess=0.7.0=pypi_0
+pure-eval=0.2.2=pypi_0
+pyan=0.1.3=pypi_0
+pyarrow=11.0.0=pypi_0
+pyasn1=0.4.8=pypi_0
+pyasn1-modules=0.2.8=pypi_0
+pycosat=0.6.4=py38h5eee18b_0
+pycparser=2.21=pyhd3eb1b0_0
+pydicom=2.4.4=pypi_0
+pyflagser=0.4.7=pypi_0
+pygments=2.15.1=pypi_0
+pynvml=11.5.0=pypi_0
+pyopenssl=23.0.0=py38h06a4308_0
+pyparsing=3.0.9=pypi_0
+pypyrtools=0.2.3=pypi_0
+pyrallis=0.3.1=pypi_0
+pyre-extensions=0.0.29=pypi_0
+pyrtools=1.0.1=pypi_0
+pysocks=1.7.1=py38h06a4308_0
+python=3.8.16=h7a1cb2a_3
+python-dateutil=2.8.2=pypi_0
+python-json-logger=2.0.7=pypi_0
+pytorch-cuda=11.6=h867d48c_1
+pytorch-fid=0.3.0=pypi_0
+pytorch-mutex=1.0=cuda
+pytz=2022.7.1=pypi_0
+pywavelets=1.4.1=pypi_0
+pyyaml=6.0=pypi_0
+pyzmq=25.1.0=pypi_0
+qtconsole=5.4.3=pypi_0
+qtpy=2.3.1=pypi_0
+readline=8.2=h5eee18b_0
+referencing=0.30.0=pypi_0
+regex=2023.3.23=pypi_0
+requests=2.30.0=pypi_0
+requests-oauthlib=1.3.1=pypi_0
+responses=0.18.0=pypi_0
+rfc3339-validator=0.1.4=pypi_0
+rfc3986-validator=0.1.1=pypi_0
+rich=13.3.5=pypi_0
+rpds-py=0.9.2=pypi_0
+rsa=4.9=pypi_0
+ruamel.yaml=0.17.21=py38h5eee18b_0
+ruamel.yaml.clib=0.2.6=py38h5eee18b_1
+safetensors=0.3.0=pypi_0
+scikit-image=0.19.0=pypi_0
+scikit-learn=1.3.2=pypi_0
+scipy=1.10.1=pypi_0
+segment-anything=1.0=pypi_0
+send2trash=1.8.2=pypi_0
+sentencepiece=0.1.99=pypi_0
+sentry-sdk=1.17.0=pypi_0
+setproctitle=1.3.2=pypi_0
+setuptools=65.6.3=py38h06a4308_0
+six=1.16.0=pyhd3eb1b0_1
+sklearn=0.0.post5=pypi_0
+smmap=5.0.0=pypi_0
+sniffio=1.3.0=pypi_0
+soupsieve=2.4.1=pypi_0
+sqlite=3.41.1=h5eee18b_0
+stack-data=0.6.2=pypi_0
+style=1.1.0=pypi_0
+sympy=1.12=pypi_0
+tabulate=0.9.0=pypi_0
+tenacity=8.4.0=pypi_0
+tensorboard=2.12.3=pypi_0
+tensorboard-data-server=0.7.0=pypi_0
+tensorboard-plugin-wit=1.8.1=pypi_0
+tensorflow=2.12.0=pypi_0
+tensorflow-estimator=2.12.0=pypi_0
+tensorflow-io-gcs-filesystem=0.32.0=pypi_0
+termcolor=2.3.0=pypi_0
+terminado=0.17.1=pypi_0
+texttable=1.7.0=pypi_0
+threadpoolctl=3.1.0=pypi_0
+tifffile=2023.4.12=pypi_0
+timm=0.9.7=pypi_0
+tinycss2=1.2.1=pypi_0
+tk=8.6.12=h1ccaba5_0
+tokenizers=0.13.2=pypi_0
+tomli=2.0.1=pypi_0
+toolz=0.12.0=py38h06a4308_0
+torch=2.0.0=pypi_0
+torchaudio=0.13.0+cu116=pypi_0
+torchmetrics=0.11.4=pypi_0
+torchvision=0.14.0+cu116=pypi_0
+tornado=6.3.2=pypi_0
+tqdm=4.65.0=pypi_0
+traitlets=5.9.0=pypi_0
+transformers=4.29.0=pypi_0
+triton=2.0.0=pypi_0
+typing-inspect=0.8.0=pypi_0
+typing_extensions=4.4.0=py38h06a4308_0
+unrar=0.4=pypi_0
+update=0.0.1=pypi_0
+uri-template=1.3.0=pypi_0
+urllib3=1.26.14=py38h06a4308_0
+wandb=0.14.0=pypi_0
+wcwidth=0.2.6=pypi_0
+webcolors=1.13=pypi_0
+webencodings=0.5.1=pypi_0
+websocket-client=1.6.1=pypi_0
+werkzeug=2.2.3=pypi_0
+wheel=0.38.4=py38h06a4308_0
+widgetsnbextension=4.0.8=pypi_0
+wrapt=1.14.1=pypi_0
+xxhash=3.2.0=pypi_0
+xz=5.2.10=h5eee18b_1
+yapf=0.33.0=pypi_0
+yarl=1.8.2=pypi_0
+zipp=3.15.0=pypi_0
+zlib=1.2.13=h5eee18b_0
+zstandard=0.19.0=py38h5eee18b_0
+zstd=1.5.4=hc292b87_0