[
  {
    "path": "Examples/Assemble_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.Assemble import Assemble\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom sklearn.svm import SVC\nimport numpy as np\n\nfile = open(\"../Result/Assemble_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# Base estimater\nSVM=SVC(probability=True)\n\nmodel=Assemble(T=100,base_estimator=SVM,evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n"
  },
  {
    "path": "Examples/CIFAR10_imbalance.py",
    "content": ""
  },
  {
    "path": "Examples/CoReg_Boston.py",
    "content": "from LAMDA_SSL.Algorithm.Regression.CoReg import CoReg\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\nimport numpy as np\n\nfile = open(\"../Result/CoReg_Boston.txt\", \"w\")\n\ndataset=Boston(labeled_size=0.3,test_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\nmodel=CoReg(evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n"
  },
  {
    "path": "Examples/Co_Training_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.Co_Training import Co_Training\nfrom LAMDA_SSL.Dataset.Tabular.Wine import Wine\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Split.ViewSplit import ViewSplit\nimport numpy as np\n\nfile = open(\"../Result/Co_Training_BreastCancer.txt\", \"w\")\n\ndataset=Wine(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\n# View split\nsplit_labeled_X=ViewSplit(labeled_X,shuffle=False)\nsplit_unlabeled_X=ViewSplit(unlabeled_X,shuffle=False)\nsplit_test_X=ViewSplit(test_X,shuffle=False)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=Co_Training(evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=split_labeled_X,y=labeled_y,unlabeled_X=split_unlabeled_X)\n\nperformance=model.evaluate(X=split_test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/Co_Training_Wine.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.Co_Training import Co_Training\nfrom LAMDA_SSL.Dataset.Tabular.Wine import Wine\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Split.ViewSplit import ViewSplit\nimport numpy as np\n\nfile = open(\"../Result/Co_Training_Wine.txt\", \"w\")\n\ndataset=Wine(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\n# View split\nsplit_labeled_X=ViewSplit(labeled_X,shuffle=False)\nsplit_unlabeled_X=ViewSplit(unlabeled_X,shuffle=False)\nsplit_test_X=ViewSplit(test_X,shuffle=False)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=Co_Training(binary=False,evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=split_labeled_X,y=labeled_y,unlabeled_X=split_unlabeled_X)\n\nperformance=model.evaluate(X=split_test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/Constrained_Seed_k_means_Wine.py",
    "content": "from LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means import Constrained_Seed_k_means\nfrom LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score import Davies_Bouldin_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score import Fowlkes_Mallows_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Jaccard_Score import Jaccard_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Silhouette_Score import Silhouette_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Rand_Score import Rand_Score\nfrom LAMDA_SSL.Dataset.Tabular.Wine import Wine\nimport numpy as np\n\nfile = open(\"../Result/Constrained_Seed_k_means_Wine.txt\", \"w\")\n\ndataset = Wine(labeled_size=0.2, stratified=True, shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n\nevaluation={\n    'Fowlkes_Mallows_Score':Fowlkes_Mallows_Score(),\n    'Jaccard_Score':Jaccard_Score(average='macro'),\n    'Rand_Score':Rand_Score(),\n    'Davies_Bouldin_Score':Davies_Bouldin_Score(),\n    'Silhouette_Score':Silhouette_Score()\n}\n\nmodel = Constrained_Seed_k_means(k=3,evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(y=np.hstack([labeled_y, unlabeled_y]),Transductive=True)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n"
  },
  {
    "path": "Examples/Constrained_k_means_Wine.py",
    "content": "from LAMDA_SSL.Algorithm.Clustering.Constrained_k_means import Constrained_k_means\nfrom LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score import Davies_Bouldin_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score import Fowlkes_Mallows_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Jaccard_Score import Jaccard_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Silhouette_Score import Silhouette_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Rand_Score import Rand_Score\nfrom LAMDA_SSL.Dataset.Tabular.Wine import Wine\nimport numpy as np\n\nfile = open(\"../Result/Constrained_k_means_Wine.txt\", \"w\")\n\ndataset=Wine(labeled_size=0.2,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n\nevaluation={\n    'Fowlkes_Mallows_Score':Fowlkes_Mallows_Score(),\n    'Jaccard_Score':Jaccard_Score(average='macro'),\n    'Rand_Score':Rand_Score(),\n    'Davies_Bouldin_Score':Davies_Bouldin_Score(),\n    'Silhouette_Score':Silhouette_Score()\n}\n\nml=[]\ncl=[]\nfor i in range(labeled_X.shape[0]):\n    for j in range(i+1,labeled_X.shape[0]):\n        if labeled_y[i]==labeled_y[j]:\n            ml.append({i,j})\n        else:\n            cl.append({i,j})\n\nmodel=Constrained_k_means(k=3,evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=np.vstack((labeled_X,unlabeled_X)),ml=ml,cl=cl)\n\nperformance=model.evaluate(y=np.hstack([labeled_y, unlabeled_y]),Transductive=True)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/FixMatch_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Network.FT_Transformer import FT_Transformer\nimport numpy as np\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Augmentation.Tabular.Noise import Noise\n\nfile = open(\"../Result/FixMatch_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nlabeled_dataset=LabeledDataset(transform=ToTensor())\nunlabeled_dataset=UnlabeledDataset(transform=ToTensor())\ntest_dataset=UnlabeledDataset(transform=ToTensor())\n\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(10000))\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nweak_augmentation=Noise(0.1)\nstrong_augmentation=Noise(0.2)\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\nmodel=FixMatch(labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset,\n                test_dataset=test_dataset, device='cuda:0', augmentation=augmentation,\n                network=FT_Transformer(dim_in=labeled_X.shape[1], num_classes=2),num_it_epoch=10000,labeled_sampler=labeled_sampler, optimizer=Adam(lr=1e-4),\n                scheduler=None, weight_decay=1e-5,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n"
  },
  {
    "path": "Examples/FixMatch_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineWarmup import CosineWarmup\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=False,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineWarmup(num_cycles=7./16,num_training_steps=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/FixMatch_CIFAR10.txt\", \"w\")\n\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=1.0,mu=7,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               evaluation=evaluation,\n               file=file,\n               verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n\n"
  },
  {
    "path": "Examples/FixMatch_SST2.py",
    "content": "from LAMDA_SSL.Dataset.Text.SST2 import SST2\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Augmentation.Text.TFIDFReplacement import TFIDFReplacement\nfrom LAMDA_SSL.Augmentation.Text.RandomSwap import RandomSwap\nfrom LAMDA_SSL.Network.TextRCNN import TextRCNN\nfrom LAMDA_SSL.Transform.Text.GloVe import Glove\n\n# dataset\ndataset=SST2(root='..\\Download\\SST2',stratified=True,shuffle=True,download=False,vectors=Glove(cache='..\\Download\\Glove\\.vector_cache'),length=50,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\nweak_augmentation=RandomSwap(n=1)\n\nstrong_augmentation=TFIDFReplacement(text=labeled_X,p=0.7)\n\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=TextRCNN(n_vocab=dataset.vectors.vec.vectors.shape[0],embedding_dim=dataset.vectors.vec.vectors.shape[1],\n                 pretrained_embeddings=dataset.vectors.vec.vectors,len_seq=50,\n                 num_classes=2)\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/FixMatch_SST2.txt\", \"w\")\n\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,ema_decay=0.999,weight_decay=5e-4,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset, test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader, unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader, test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,\n               evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/FlexMatch_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FlexMatch import FlexMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Scheduler.CosineWarmup import CosineWarmup\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineWarmup(num_cycles=7./16,num_training_steps=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/FlexMatch_CIFAR10.txt\", \"w\")\n\nmodel=FlexMatch(threshold=0.95,lambda_u=1.0,T=1.0,num_classes=10,\n               use_hard_labels=True,threshold_warmup=True,mu=7,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,valid_dataloader=valid_dataloader,test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,evaluation=evaluation,\n               verbose=True,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/FlexMatch_SST2.py",
    "content": "from LAMDA_SSL.Dataset.Text.SST2 import SST2\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FlexMatch import FlexMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Augmentation.Text.TFIDFReplacement import TFIDFReplacement\nfrom LAMDA_SSL.Augmentation.Text.RandomSwap import RandomSwap\nfrom LAMDA_SSL.Network.TextRCNN import TextRCNN\nfrom LAMDA_SSL.Transform.Text.GloVe import Glove\n\n# dataset\ndataset=SST2(root='..\\Download\\SST2',stratified=True,shuffle=True,download=False,vectors=Glove(cache='..\\Download\\Glove\\.vector_cache'),length=50,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\nweak_augmentation=RandomSwap(n=1)\n\nstrong_augmentation=TFIDFReplacement(text=labeled_X,p=0.7)\n\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=TextRCNN(n_vocab=dataset.vectors.vec.vectors.shape[0],embedding_dim=dataset.vectors.vec.vectors.shape[1],\n                 pretrained_embeddings=dataset.vectors.vec.vectors,len_seq=50,\n                 num_classes=2)\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/FixMatch_SST2.txt\", \"w\")\n\nmodel=FlexMatch(threshold=0.95,lambda_u=1.0,T=1.0,mu=7,ema_decay=0.999,weight_decay=5e-4,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset, test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader, unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader, test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,\n               evaluation=evaluation,verbose=True,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/GAT_Cora.py",
    "content": "from LAMDA_SSL.Dataset.Graph.Cora import Cora\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Algorithm.Classification.GAT import GAT\nfile = open(\"../Result/GAT_Cora.txt\", \"w\")\n\ndataset=Cora(labeled_size=0.2,root='..\\Download\\Cora',random_state=0,default_transforms=True)\ndata=dataset.data\ndata=dataset.transform.fit_transform(data)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\noptimizer=Adam(lr=0.01)\n\nmodel=GAT(\n    dim_in=1433,\n    heads=16,\n    dropout=0,\n    epoch=500,\n    eval_epoch=200,\n    weight_decay=5e-4,\n    device='cpu',\n    optimizer=optimizer,\n    evaluation=evaluation,\n    file=file,\n    verbose=True\n)\n\nmodel.fit(data,valid_X=data.val_mask)\n\nperformance=model.evaluate(X=data.test_mask)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/GCN_Cora.py",
    "content": "from LAMDA_SSL.Dataset.Graph.Cora import Cora\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Algorithm.Classification.GCN import GCN\nfile = open(\"../Result/GCN_Cora.txt\", \"w\")\n\ndataset=Cora(labeled_size=0.2,root='..\\Download\\Cora',random_state=0,default_transforms=True)\ndata=dataset.data\ndata=dataset.transform.fit_transform(data)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\noptimizer=Adam(lr=0.01)\n\nmodel=GCN(\n    dim_in=1433,\n    normalize=True,\n    epoch=500,\n    eval_epoch=200,\n    weight_decay=5e-4,\n    device='cpu',\n    optimizer=optimizer,\n    evaluation=evaluation,\n    file=file,\n    verbose=True\n)\n\nmodel.fit(data,valid_X=data.val_mask)\n\nperformance=model.evaluate(X=data.test_mask)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/ICTReg_Boston.py",
    "content": "from LAMDA_SSL.Augmentation.Tabular.Noise import Noise\nimport torch.nn as nn\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.MLPReg import MLPReg\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Regression.ICTReg import ICTReg\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nimport numpy as np\n\n# dataset\ndataset=Boston(test_size=0.3,labeled_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nlabeled_dataset=LabeledDataset(transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Noise(noise_level=0.01)\n\n# optimizer\noptimizer=SGD(lr=0.001,momentum=0.9,nesterov=True)\nscheduler=CosineAnnealingLR(eta_min=0,T_max=4000)\n\n# network\nnetwork=MLPReg(hidden_dim=[100,50,10],activations=[nn.ReLU(),nn.ReLU(),nn.ReLU()],dim_in=labeled_X.shape[-1])\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\nfile = open(\"../Result/ICTReg_Boston.txt\", \"w\")\n\nmodel=ICTReg(alpha=0.5,lambda_u=0.001,warmup=1/64,\n               mu=1,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=4000,\n               num_it_total=4000,\n               eval_it=200,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,\n               optimizer=optimizer,scheduler=scheduler,\n               evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/ICT_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.ICT import ICT\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                        ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/ICT_CIFAR10.txt\", \"w\")\n\nmodel=ICT(alpha=0.5,lambda_u=100,warmup=1/64,mu=1,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               evaluation=evaluation,\n               file=file,\n               verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n"
  },
  {
    "path": "Examples/ImprovedGAN_MNIST.py",
    "content": "from LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Algorithm.Classification.ImprovedGAN import ImprovedGAN\nimport torch.nn as nn\nfrom LAMDA_SSL.Dataset.Vision.Mnist import Mnist\ndataset=Mnist(root='..\\Download\\mnist',labeled_size=6000,shuffle=True,download=False,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=100*540)\nunlabeled_sampler=RandomSampler(replacement=False)\ntest_sampler=SequentialSampler()\nvalid_sampler=SequentialSampler()\n\n# optimizer\noptimizer=Adam(lr=3e-4)\n\n# evalutation\nevaluation={\n    'Accuracy':Accuracy(),\n    'Top_5_Accuracy':Top_k_Accurary(k=5),\n    'Precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_Matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/ImprovedGAN_MNIST.txt\", \"w\")\n\nmodel=ImprovedGAN(lambda_u=1,\n                     dim_z=100,dim_in=(28,28),hidden_G=[500,500],\n                     hidden_D=[1000,500,250,250,250],\n                     noise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5],\n                     activations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus()],\n                     activations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                     mu=1,epoch=100,num_it_epoch=540,\n                     num_it_total=540*100,eval_it=2000,device='cpu',\n                     labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset, valid_dataset=valid_dataset,\n                     test_dataset=test_dataset,\n                     labeled_sampler=labeled_sampler, unlabeled_sampler=unlabeled_sampler, valid_sampler=valid_sampler,\n                     test_sampler=test_sampler,\n                     labeled_dataloader=labeled_dataloader, unlabeled_dataloader=unlabeled_dataloader,\n                     valid_dataloader=valid_dataloader, test_dataloader=test_dataloader,\n                     optimizer=optimizer,evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\nfake_X=model.generate(num=100)\nfor _ in range(100):\n    img=ToImage()(fake_X[_]*256)\n    img.convert('RGB').save('../Result/Imgs/ImprovedGAN/' + str(_) + '.jpg')\n\n\n\n\n"
  },
  {
    "path": "Examples/LabelPropagation_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.LabelPropagation import LabelPropagation\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nimport numpy as np\n\nfile = open(\"../Result/LabelPropagation_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=LabelPropagation(gamma=1,max_iter=10000,evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y,Transductive=False)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/LabelSpreading_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.LabelSpreading import LabelSpreading\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nimport numpy as np\n\nfile = open(\"../Result/LabelSpreading_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=LabelSpreading(gamma=1,max_iter=10000,evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y,Transductive=False)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/LadderNetwork_MNIST.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.LadderNetwork import LadderNetwork\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Scheduler.LinearWarmup import LinearWarmup\nfrom LAMDA_SSL.Dataset.Vision.Mnist import Mnist\nimport torch.nn as nn\n\ndataset=Mnist(root='..\\Download\\mnist',labeled_size=6000,stratified=True,shuffle=True,download=False,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=100*540)\nunlabeled_sampler=RandomSampler(replacement=False)\ntest_sampler=SequentialSampler()\nvalid_sampler=SequentialSampler()\n\n# optimizer\noptimizer=Adam(lr=0.02)\n\n# scheduler\nscheduler=LinearWarmup(num_warmup_steps=15,num_training_steps=10,verbose=False)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/LadderNetwork_MNIST.txt\", \"w\")\n\nmodel=LadderNetwork(noise_std=0.2,\n                     lambda_u=[0.1, 0.1, 0.1, 0.1, 0.1, 10., 1000.],\n                     dim_encoder=[1000, 500, 250, 250, 250],\n                     encoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                     mu=1,weight_decay=5e-4,\n                     epoch=10,num_it_epoch=540,num_it_total=540*10,eval_epoch=1,\n                     optimizer=optimizer,scheduler=scheduler,evaluation=evaluation,device='cpu',\n                     labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset, valid_dataset=valid_dataset,\n                     test_dataset=test_dataset,\n                     labeled_sampler=labeled_sampler, unlabeled_sampler=unlabeled_sampler, valid_sampler=valid_sampler,\n                     test_sampler=test_sampler,\n                     labeled_dataloader=labeled_dataloader, unlabeled_dataloader=unlabeled_dataloader,\n                     valid_dataloader=valid_dataloader, test_dataloader=test_dataloader,\n                     file=None,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/LapSVM_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.LapSVM import LapSVM\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nimport numpy as np\n\nfile = open(\"../Result/LapSVM_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=LapSVM(neighbor_mode='connectivity',\n           gamma_d=0.03,\n           n_neighbor= 5,\n           gamma_k=0.03,\n           gamma_A= 0.03,\n           gamma_I= 0,\n           evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/MeanTeacherReg_Boston.py",
    "content": "from LAMDA_SSL.Augmentation.Tabular.Noise import Noise\nimport torch.nn as nn\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.MLPReg import MLPReg\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Regression.MeanTeacherReg import MeanTeacherReg\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nimport numpy as np\n\n# dataset\ndataset=Boston(test_size=0.3,labeled_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nlabeled_dataset=LabeledDataset(transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Noise(noise_level=0.01)\n\n# optimizer\noptimizer=SGD(lr=0.001,momentum=0.9,nesterov=True)\nscheduler=CosineAnnealingLR(eta_min=0,T_max=4000)\n\n# network\nnetwork=MLPReg(hidden_dim=[100,50,10],activations=[nn.ReLU(),nn.ReLU(),nn.ReLU()],dim_in=labeled_X.shape[-1])\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\nfile = open(\"../Result/MeanTeacherReg_Boston.txt\", \"w\")\n\nmodel=MeanTeacherReg(lambda_u=0,warmup=0.4,\n               mu=1,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=4000,\n               num_it_total=4000,\n               eval_it=200,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,\n               optimizer=optimizer,scheduler=scheduler,\n               evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/MeanTeacher_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.MeanTeacher import MeanTeacher\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/MeanTeacher_CIFAR10.txt\", \"w\")\n\nmodel=MeanTeacher(lambda_u=50,warmup=0.4,mu=1,weight_decay=5e-4,ema_decay=0.999,\n                  epoch=1, num_it_epoch=2 ** 20, num_it_total=2 ** 20, eval_it=2000, device='cpu',\n                  labeled_dataset=labeled_dataset,\n                  unlabeled_dataset=unlabeled_dataset,\n                  valid_dataset=valid_dataset,\n                  test_dataset=test_dataset,\n                  labeled_sampler=labeled_sampler,\n                  unlabeled_sampler=unlabeled_sampler,\n                  valid_sampler=valid_sampler,\n                  test_sampler=test_sampler,\n                  labeled_dataloader=labeled_dataloader,\n                  unlabeled_dataloader=unlabeled_dataloader,\n                  valid_dataloader=valid_dataloader,\n                  test_dataloader=test_dataloader,\n                  augmentation=augmentation,\n                  network=network,\n                  optimizer=optimizer,\n                  scheduler=scheduler,\n                  evaluation=evaluation,\n                  file=file,\n                  verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n"
  },
  {
    "path": "Examples/MixMatch_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.MixMatch import MixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                        ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/MixMatch_CIFAR10.txt\", \"w\")\n\nmodel=MixMatch(alpha=0.5,lambda_u=100,T=0.5,warmup=1 / 64,mu=1,\n               weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,\n               eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               evaluation=evaluation,\n               file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/ParallelDistributed.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Distributed.DataParallel import DataParallel\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=False,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=30)),\n                              ('Cutout',Cutout(v=0.5,fill=(127,127,127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# parallel\nparallel=DataParallel(device_ids=['cuda:0','cuda:1'],output_device='cuda:0')\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/FixMatch_CIFAR10.txt\", \"w\")\n\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=1,num_it_total=1,eval_it=1,eval_epoch=1,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               parallel=parallel,\n               evaluation=evaluation,\n               file=file,\n               verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/Parameter_Search.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.model_selection._search import RandomizedSearchCV\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=False,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=30)),\n                              ('Cutout',Cutout(v=0.5,fill=(127,127,127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/Parameter_Searcn.txt\", \"w\")\n\nmodel=FixMatch(T=0.5,mu=7,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               file=None,\n               verbose=False)\n\nparam_dict = {\"threshold\": [0.7, 1],\n              \"lambda_u\":[0.8,1]\n              }\n\nrandom_search = RandomizedSearchCV(model, param_distributions=param_dict,\n                                   n_iter=1, cv=4,scoring='accuracy')\n\nrandom_search.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nbest_params=random_search.best_params_\n\nprint(best_params,file=file)"
  },
  {
    "path": "Examples/PiModelReg_Boston.py",
    "content": "from LAMDA_SSL.Augmentation.Tabular.Noise import Noise\nimport torch.nn as nn\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.MLPReg import MLPReg\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Regression.PiModelReg import PiModelReg\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nimport numpy as np\n\n# dataset\ndataset=Boston(test_size=0.3,labeled_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nlabeled_dataset=LabeledDataset(transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(4000))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Noise(noise_level=0.01)\n\n# optimizer\noptimizer=SGD(lr=0.001,momentum=0.9,nesterov=True)\nscheduler=CosineAnnealingLR(eta_min=0,T_max=4000)\n\n# network\nnetwork=MLPReg(hidden_dim=[100,50,10],activations=[nn.ReLU(),nn.ReLU(),nn.ReLU()],dim_in=labeled_X.shape[-1])\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\nfile = open(\"../Result/PiModelReg_Boston.txt\", \"w\")\n\nmodel=PiModelReg(lambda_u=0.001,warmup=0.4,\n               mu=1,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=4000,\n               num_it_total=4000,\n               eval_it=200,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,\n               optimizer=optimizer,scheduler=scheduler,\n               evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n"
  },
  {
    "path": "Examples/PiModel_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.PiModel import PiModel\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/PiModel_CIFAR10.txt\", \"w\")\n\nmodel=PiModel(lambda_u=10,warmup=0.4,mu=1,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,\n               eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               evaluation=evaluation,\n               file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n"
  },
  {
    "path": "Examples/PseudoLabel_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.PseudoLabel import PseudoLabel\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                        ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/PseudoLabel_CIFAR10.txt\", \"w\")\n\nmodel=PseudoLabel(threshold=0.95,lambda_u=1,warmup=0.4,mu=1,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,\n               eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               evaluation=evaluation,\n               file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nvalid_performance=model.valid_performance\nprint(valid_performance,file=file)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n"
  },
  {
    "path": "Examples/ReMixMatch_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.ReMixMatch import ReMixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=(10,4),depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/ReMixMatch_CIFAR10.txt\", \"w\")\n\nmodel=ReMixMatch(alpha=0.5,lambda_u=1.5,lambda_s=0.5,\n                 lambda_rot=0.5,T=0.5,warmup=0.015625,mu=1,\n                 weight_decay=5e-4, ema_decay=0.999,\n                 epoch=1, num_it_epoch=2 ** 20, num_it_total=2 ** 20,\n                 eval_it=2000, device='cpu',\n                 labeled_dataset=labeled_dataset,\n                 unlabeled_dataset=unlabeled_dataset,\n                 valid_dataset=valid_dataset,\n                 test_dataset=test_dataset,\n                 labeled_sampler=labeled_sampler,\n                 unlabeled_sampler=unlabeled_sampler,\n                 valid_sampler=valid_sampler,\n                 test_sampler=test_sampler,\n                 labeled_dataloader=labeled_dataloader,\n                 unlabeled_dataloader=unlabeled_dataloader,\n                 valid_dataloader=valid_dataloader,\n                 test_dataloader=test_dataloader,\n                 augmentation=augmentation,\n                 network=network,\n                 optimizer=optimizer,\n                 scheduler=scheduler,\n                 evaluation=evaluation,\n                 file=file, verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n"
  },
  {
    "path": "Examples/S4L_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Algorithm.Classification.S4L import S4L\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                      ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=(10,4),depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/S4L_CIFAR10.txt\", \"w\")\n\nmodel=S4L(lambda_u=1.5,mu=1,weight_decay=5e-4, ema_decay=0.999,\n                 epoch=1, num_it_epoch=2 ** 20, num_it_total=2 ** 20,\n                 eval_it=2000, device='cpu',\n                 labeled_dataset=labeled_dataset,\n                 unlabeled_dataset=unlabeled_dataset,\n                 valid_dataset=valid_dataset,\n                 test_dataset=test_dataset,\n                 labeled_sampler=labeled_sampler,\n                 unlabeled_sampler=unlabeled_sampler,\n                 valid_sampler=valid_sampler,\n                 test_sampler=test_sampler,\n                 labeled_dataloader=labeled_dataloader,\n                 unlabeled_dataloader=unlabeled_dataloader,\n                 valid_dataloader=valid_dataloader,\n                 test_dataloader=test_dataloader,\n                 augmentation=augmentation,\n                 network=network,\n                 optimizer=optimizer,\n                 scheduler=scheduler,\n                 evaluation=evaluation,\n                 file=file, verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n"
  },
  {
    "path": "Examples/SDNE_Cora.py",
    "content": "from LAMDA_SSL.Dataset.Graph.Cora import Cora\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Scheduler.StepLR import StepLR\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Algorithm.Classification.SDNE import SDNE\n\nfile = open(\"../Result/SDNE_Cora.txt\", \"w\")\n\ndataset=Cora(labeled_size=0.2,root='..\\Download\\Cora',random_state=0,default_transforms=True)\ndata=dataset.data\ndata=dataset.transform.fit_transform(data)\n\noptimizer=Adam(lr=0.001)\n\nscheduler= StepLR(step_size=10, gamma=0.9)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=SDNE(\n    hidden_layers=[1000,1000],\n    gamma=1e-5,\n    alpha=1e-3,\n    beta=10,\n    epoch=500,\n    eval_epoch=200,\n    weight_decay=0,\n    device='cpu',\n    optimizer=optimizer,\n    scheduler=scheduler,\n    evaluation=evaluation,\n    verbose=True,\n    file=file\n)\n\nmodel.fit(data,valid_X=data.val_mask)\n\nperformance=model.evaluate(X=data.test_mask)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/SSGMM_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.SSGMM import SSGMM\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nimport numpy as np\n\nfile = open(\"../Result/SSGMM_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\n\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=SSGMM(evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/SSVAE_MNIST.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.SSVAE import SSVAE\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nimport torch.nn as nn\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Dataset.Vision.Mnist import Mnist\n\n# dataset\ndataset=Mnist(root='..\\Download\\mnist',labeled_size=6000,stratified=True,shuffle=True,download=False,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=100*540)\nunlabeled_sampler=RandomSampler(replacement=False)\ntest_sampler=SequentialSampler()\nvalid_sampler=SequentialSampler()\n\n# optimizer\noptimizer=Adam(lr=3e-4)\n\n# evalutation\nevaluation={\n    'Accuracy':Accuracy(),\n    'Top_5_Accuracy':Top_k_Accurary(k=5),\n    'Precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_Matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/SSVAE_MNIST.txt\", \"w\")\n\nmodel=SSVAE(alpha=5,num_labeled=6000,dim_in=(28,28),num_classes=10,\n             dim_z=100,\n             dim_hidden_de=[500, 500],\n             dim_hidden_en_y=[500, 500], dim_hidden_en_z=[500, 500],\n             activations_de=[nn.Softplus(), nn.Softplus()],\n             activations_en_y=[nn.Softplus(), nn.Softplus()],\n             activations_en_z=[nn.Softplus(), nn.Softplus()],\n             mu=1,weight_decay=0,epoch=100,num_it_epoch=540,num_it_total=540*100,eval_it=2000,device='cpu',\n             labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,\n             labeled_sampler=labeled_sampler,unlabeled_sampler=unlabeled_sampler,valid_sampler=valid_sampler,test_sampler=test_sampler,\n             labeled_dataloader=labeled_dataloader,unlabeled_dataloader=unlabeled_dataloader,valid_dataloader=valid_dataloader,test_dataloader=test_dataloader,\n             optimizer=optimizer,\n             evaluation=evaluation,\n             file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\nX=model.generate(100)\n\nfor _ in range(100):\n    img=ToImage()(X[_]*256)\n    img.convert('RGB').save('../Result/Imgs/SSVAE/' + str(_) + '.jpg')\n"
  },
  {
    "path": "Examples/Save_Load_Model.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nimport pickle\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=False,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=30)),\n                              ('Cutout',Cutout(v=0.5,fill=(127,127,127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/Save_Load.txt\", \"w\")\n\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,weight_decay=5e-4,ema_decay=0.999,\n               epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cpu',\n               labeled_dataset=labeled_dataset,\n               unlabeled_dataset=unlabeled_dataset,\n               valid_dataset=valid_dataset,\n               test_dataset=test_dataset,\n               labeled_sampler=labeled_sampler,\n               unlabeled_sampler=unlabeled_sampler,\n               valid_sampler=valid_sampler,\n               test_sampler=test_sampler,\n               labeled_dataloader=labeled_dataloader,\n               unlabeled_dataloader=unlabeled_dataloader,\n               valid_dataloader=valid_dataloader,\n               test_dataloader=test_dataloader,\n               augmentation=augmentation,\n               network=network,\n               optimizer=optimizer,\n               scheduler=scheduler,\n               evaluation=evaluation,\n               file=None,\n               verbose=False)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\npath='../Save/Fixmatch.pkl'\nwith open(path, 'wb') as f:\n    pickle.dump(model, f)\n\nwith open(path, 'rb') as f:\n    model = pickle.load(f)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n"
  },
  {
    "path": "Examples/SemiBoost_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.SemiBoost import SemiBoost\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom sklearn.svm import SVC\nimport numpy as np\n\nfile = open(\"../Result/SemiBoost_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nSVM=SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmodel=SemiBoost(gamma=10,base_estimator=SVM,evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/TSVM_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.TSVM import TSVM\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nimport numpy as np\n\nfile = open(\"../Result/TSVM_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nmodel=TSVM(evaluation=evaluation,file=file)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y,Transductive=False)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n"
  },
  {
    "path": "Examples/TemporalEnsembling_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.TemporalEnsembling import TemporalEnsembling\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=460*100)\nunlabeled_sampler=RandomSampler(replacement=False)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                    ])\n\n# optimizer\noptimizer=SGD(lr=0.1,momentum=0.9,weight_decay=5e-4)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0.0001,T_max=400)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/TemporalEnsembling_CIFAR10.txt\", \"w\")\n\nmodel=TemporalEnsembling(lambda_u=30,ema_weight=0.6,warmup=0.4,mu=1,weight_decay=5e-4,epoch=400,num_it_epoch=460,\n                         num_it_total=460*400,eval_epoch=10,device='cpu',\n                         labeled_dataset=labeled_dataset,\n                         unlabeled_dataset=unlabeled_dataset,\n                         valid_dataset=valid_dataset,\n                         test_dataset=test_dataset,\n                         labeled_sampler=labeled_sampler,\n                         unlabeled_sampler=unlabeled_sampler,\n                         valid_sampler=valid_sampler,\n                         test_sampler=test_sampler,\n                         labeled_dataloader=labeled_dataloader,\n                         unlabeled_dataloader=unlabeled_dataloader,\n                         valid_dataloader=valid_dataloader,\n                         test_dataloader=test_dataloader,\n                         augmentation=augmentation,\n                         network=network,\n                         optimizer=optimizer,\n                         scheduler=scheduler,\n                         evaluation=evaluation,\n                         file=file, verbose=True\n                         )\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)\n\n\n\n\n\n"
  },
  {
    "path": "Examples/Tri_Training_BreastCancer.py",
    "content": "from LAMDA_SSL.Algorithm.Classification.Tri_Training import Tri_Training\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom sklearn.svm import SVC\nimport numpy as np\n\nfile = open(\"../Result/Tri_Training_BreastCancer.txt\", \"w\")\n\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\n# Pre_transform\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\n\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nSVM=SVC(C=1.0,kernel='linear',probability=True,gamma='auto')\n\nmodel=Tri_Training(base_estimator=SVM,evaluation=evaluation,file=file,verbose=True)\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/UDA_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineWarmup import CosineWarmup\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.UDA import UDA\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\n\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineWarmup(num_cycles=7./16,num_training_steps=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/UDA_CIFAR10.txt\", \"w\")\n\nmodel=UDA(threshold=0.8,lambda_u=1.0,T=0.4,mu=7,\n          weight_decay=5e-4, ema_decay=0.999,\n          epoch=1, num_it_epoch=2 ** 20, num_it_total=2 ** 20,\n          eval_it=2000, device='cpu',\n          labeled_dataset=labeled_dataset,\n          unlabeled_dataset=unlabeled_dataset,\n          valid_dataset=valid_dataset,\n          test_dataset=test_dataset,\n          labeled_sampler=labeled_sampler,\n          unlabeled_sampler=unlabeled_sampler,\n          valid_sampler=valid_sampler,\n          test_sampler=test_sampler,\n          labeled_dataloader=labeled_dataloader,\n          unlabeled_dataloader=unlabeled_dataloader,\n          valid_dataloader=valid_dataloader,\n          test_dataloader=test_dataloader,\n          augmentation=augmentation,\n          network=network,\n          optimizer=optimizer,\n          scheduler=scheduler,\n          evaluation=evaluation,\n          file=file, verbose=True\n          )\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "Examples/VAT_CIFAR10.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Algorithm.Classification.VAT import VAT\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\n# dataset\ndataset=CIFAR10(root='..\\Download\\cifar-10-python',labeled_size=4000,stratified=True,shuffle=True,download=False,default_transforms=True)\n\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\n\nunlabeled_X=dataset.unlabeled_X\n\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\n# sampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\n\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nfile = open(\"../Result/VAT_CIFAR10.txt\", \"w\")\n\nmodel=VAT(lambda_u=0.3,lambda_entmin=0.06,eps=6,xi=1e-6,it_vat=1,warmup=0.4,mu=1,\n          weight_decay=5e-4, ema_decay=0.999,\n          epoch=1, num_it_epoch=2 ** 20, num_it_total=2 ** 20,\n          eval_it=2000, device='cpu',\n          labeled_dataset=labeled_dataset,\n          unlabeled_dataset=unlabeled_dataset,\n          valid_dataset=valid_dataset,\n          test_dataset=test_dataset,\n          labeled_sampler=labeled_sampler,\n          unlabeled_sampler=unlabeled_sampler,\n          valid_sampler=valid_sampler,\n          test_sampler=test_sampler,\n          labeled_dataloader=labeled_dataloader,\n          unlabeled_dataloader=unlabeled_dataloader,\n          valid_dataloader=valid_dataloader,\n          test_dataloader=test_dataloader,\n          augmentation=augmentation,\n          network=network,\n          optimizer=optimizer,\n          scheduler=scheduler,\n          evaluation=evaluation,\n          file=file, verbose=True\n          )\n\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n\nperformance=model.evaluate(X=test_X,y=test_y)\n\nresult=model.y_pred\n\nprint(result,file=file)\n\nprint(performance,file=file)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/Assemble.py",
    "content": "import copy\nimport numbers\nimport numpy as np\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nfrom torch.utils.data.dataset import Dataset\nfrom sklearn.neighbors import KNeighborsClassifier\nimport LAMDA_SSL.Config.Assemble as config\n\n\nclass Assemble(InductiveEstimator, ClassifierMixin):\n    def __init__(\n            self,\n            base_estimator=config.base_estimator,\n            T=config.T,\n            alpha=config.alpha,\n            beta=config.beta,\n            evaluation=config.evaluation,\n            verbose=config.verbose,\n            file=config.file):\n        # >> Parameter:\n        # >> - base_estimator: A base learner for ensemble learning.\n        # >> - T: the number of base learners. It is also the number of iterations.\n        # >> - alpha: the weight of each sample when the sampling distribution is updated.\n        # >> - Beta: used to initialize the sampling distribution of labeled data and unlabeled data.\n        self.base_estimator = base_estimator\n        self.T = T\n        self.alpha = alpha\n        self.beta = beta\n        self.KNN = KNeighborsClassifier(n_neighbors=3)\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.w = []\n        self.f = []\n        self.y_pred = None\n        self.y_score = None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def predict_proba(self, X):\n        y_proba = 0\n        for _ in range(len(self.w)):\n            y_proba = y_proba + self.w[_] * self.f[_].predict_proba(X)\n        return y_proba\n\n    def predict(self, X):\n        y_proba = self.predict_proba(X)\n        y_pred = np.argmax(y_proba, axis=1)\n        return y_pred\n\n    def fit(self, X, y, unlabeled_X):\n        self.w = []\n        self.f = []\n        l = X.shape[0]\n        u = unlabeled_X.shape[0]\n        sample_weight = np.zeros(l + u)\n        for i in range(l):\n            sample_weight[i] = self.beta / l\n        for i in range(u):\n            sample_weight[i + l] = (1 - self.beta) / u\n        unlabeled_y = self.KNN.fit(X, y).predict(unlabeled_X)\n        classfier = copy.deepcopy(self.base_estimator)\n        X_all = np.concatenate((X, unlabeled_X))\n        y_all = np.concatenate((y, unlabeled_y))\n        classfier.fit(X_all, y_all, sample_weight=sample_weight * (l + u))\n        for i in range(self.T):\n            self.f.append(classfier)\n            _y_all = classfier.predict(X_all)\n            epsilon = 0\n            for _ in range(l + u):\n                if _y_all[_] != y_all[_]:\n                    epsilon += sample_weight[_]\n            w = np.log((1 - epsilon) / (epsilon + 1e-8)) * 0.5\n            self.w.append(w)\n            if epsilon > 0.5:\n                break\n            probas = self.predict_proba(X_all)\n            logits = np.max(probas, axis=1)\n            unlabeled_y = self.predict(unlabeled_X)\n            y_all = np.concatenate((y, unlabeled_y))\n            if isinstance(self.alpha, numbers.Number):\n                alpha = np.ones(l + u) * self.alpha\n            else:\n                alpha = self.alpha\n            sample_weight = alpha * np.exp(-logits)\n            sample_weight = (sample_weight + 1e-8) / \\\n                (sample_weight + 1e-8).sum()\n            idx_sample = np.random.choice(\n                l + u, l, False, p=sample_weight.tolist())\n            X_sample = X_all[idx_sample]\n            y_sample = y_all[idx_sample]\n            sample_weight_sample = sample_weight[idx_sample]\n            classfier = copy.deepcopy(self.base_estimator)\n            classfier.fit(\n                X_sample,\n                y_sample,\n                sample_weight_sample *\n                X_sample.shape[0])\n        return self\n\n    def evaluate(self, X, y=None):\n        if isinstance(X, Dataset) and y is None:\n            y = getattr(X, 'y')\n        self.y_score = self.predict_proba(X)\n        self.y_pred = self.predict(X)\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation, (list, tuple)):\n            performance = []\n            for eval in self.evaluation:\n                score = eval.scoring(y, self.y_pred, self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation, dict):\n            performance = {}\n            for key, val in self.evaluation.items():\n                performance[key] = val.scoring(y, self.y_pred, self.y_score)\n                if self.verbose:\n                    print(key, ' ', performance[key], file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance = self.evaluation.scoring(y, self.y_pred, self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance = performance\n            return performance\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/CAFA.py",
    "content": "from LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\r\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\r\nfrom sklearn.base import ClassifierMixin\r\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\r\nfrom LAMDA_SSL.Loss.Consistency import Consistency\r\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\r\nfrom LAMDA_SSL.utils import Bn_Controller\r\nfrom LAMDA_SSL.Network.AdversarialNet import AdversarialNet\r\nimport copy\r\nimport numpy as np\r\nimport LAMDA_SSL.Config.CAFA as config\r\nimport torch\r\nimport torch.nn.functional as F\r\nimport torch.nn as nn\r\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\r\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\r\nfrom LAMDA_SSL.utils import class_status\r\nimport math\r\ndef TempScale(p, t):\r\n    return p / t\r\n\r\ndef inverseDecaySheduler(step, initial_lr, gamma=10, power=0.75, max_iter=1000):\r\n    return initial_lr * ((1 + gamma * min(1.0, step / float(max_iter))) ** (- power))\r\n\r\ndef compute_score(inputs, model, eps):\r\n    model.eval()\r\n    inputs.requires_grad = True\r\n    _, output = model(inputs)\r\n    softmax_output = output.softmax(1)\r\n    softmax_output = TempScale(softmax_output, 0.5)\r\n    max_value, max_target = torch.max(softmax_output, dim=1)\r\n    xent = F.cross_entropy(softmax_output, max_target.detach().long())\r\n    d = torch.autograd.grad(xent, inputs)[0]\r\n    d = torch.ge(d, 0)\r\n    d = (d.float() - 0.5) * 2\r\n    # Normalizing the gradient to the same space of image\r\n    # d[0][0] = (d[0][0]) / (63.0 / 255.0)\r\n    # d[0][1] = (d[0][1]) / (62.1 / 255.0)\r\n    # d[0][2] = (d[0][2]) / (66.7 / 255.0)\r\n    inputs_hat = torch.add(inputs.data, -eps, d.detach())\r\n    _, output_hat = model(inputs_hat)\r\n    softmax_output_hat = output_hat.softmax(1)\r\n    softmax_output_hat = TempScale(softmax_output_hat, 0.5)\r\n    max_value_hat = torch.max(softmax_output_hat, dim=1).values\r\n    pred_shift = torch.abs(max_value - max_value_hat).unsqueeze(1)\r\n    model.train()\r\n    return pred_shift.detach()\r\n\r\ndef normalize_weight(x):\r\n    min_val = x.min()\r\n    max_val = x.max()\r\n    x = (x - min_val) / (max_val - min_val)\r\n    x = x / max(torch.mean(x), 1e-6)\r\n    return x.detach()\r\n\r\ndef feature_scaling(x):\r\n    min_val = x.min()\r\n    max_val = x.max()\r\n    x = (x - min_val) / (max_val - min_val)\r\n    return x.detach()\r\n\r\ndef pseudo_label_calibration(pslab, weight):\r\n    weight = weight.transpose(1, 0).expand(pslab.shape[0], -1)\r\n    weight = normalize_weight(weight)\r\n    pslab = torch.exp(pslab)\r\n    pslab = pslab * weight\r\n    pslab = pslab / torch.sum(pslab, 1, keepdim=True)\r\n    return pslab\r\n\r\ndef reverse_sigmoid(y):\r\n    return torch.log(y / (1.0 - y + 1e-10) + 1e-10)\r\n\r\ndef get_label_share_weight(domain_out, pred_shift, domain_temperature=1.0, class_temperature=1.0):\r\n    min_val = pred_shift.min()\r\n    max_val = pred_shift.max()\r\n    pred_shift = (pred_shift - min_val) / (max_val - min_val)\r\n    pred_shift = reverse_sigmoid(pred_shift)\r\n    pred_shift = pred_shift / class_temperature\r\n    pred_shift = nn.Sigmoid()(pred_shift)\r\n\r\n    domain_logit = reverse_sigmoid(domain_out)\r\n    domain_logit = domain_logit / domain_temperature\r\n    domain_out = nn.Sigmoid()(domain_logit)\r\n\r\n    weight = domain_out - pred_shift\r\n    weight = weight.detach()\r\n    return weight\r\n\r\n\r\ndef get_unlabel_share_weight(domain_out, pred_shift, domain_temperature=1.0, class_temperature=1.0):\r\n    weight = get_label_share_weight(domain_out, pred_shift, domain_temperature, class_temperature)\r\n    return -weight\r\n\r\n\r\ndef match_string(stra, strb):\r\n    '''\r\n        stra: labels.\r\n        strb: unlabeled data predicts.\r\n    '''\r\n    l_b, prob = torch.argmax(strb, dim=1), torch.max(strb, dim=1).values\r\n    permidx = torch.tensor(range(len(l_b)))\r\n\r\n    for i in range(len(l_b)):\r\n        if stra[i] != l_b[i]:\r\n            mask = (l_b[i:] == stra[i]).float()\r\n            if mask.sum() > 0:\r\n                idx_tmp = int(i + torch.argmax(prob[i:] * mask, dim=0))\r\n                tmp = permidx[i].data.clone()\r\n                permidx[i] = permidx[idx_tmp]\r\n                permidx[idx_tmp] = tmp\r\n    return permidx\r\n\r\ndef compute_class_weight(weight, label, class_weight):\r\n        for i in range(len(class_weight)):\r\n            mask = (label == i)\r\n            class_weight[i] = weight[mask].mean()\r\n        return class_weight\r\n\r\nclass CAFA(DeepModelMixin,InductiveEstimator,ClassifierMixin):\r\n    def __init__(self,lambda_u=config.lambda_u,\r\n                 warmup=config.warmup,\r\n                 mu=config.mu,\r\n                 threshold=config.threshold,\r\n                 T=config.T,\r\n                 ema_decay=config.ema_decay,\r\n                 adv_warmup=config.adv_warmup,\r\n                 weight_decay=config.weight_decay,\r\n                 eps=config.eps,\r\n                 l_domain_temper=config.l_domain_temper,\r\n                 u_domain_temper=config.u_domain_temper,\r\n                 l_class_temper=config.l_class_temper,\r\n                 u_class_temper=config.u_class_temper,\r\n                 num_classes=config.num_classes,\r\n                 discriminator=config.discriminator,\r\n                 discriminator_separate=config.discriminator_separate,\r\n                 discriminator_optimizer=config.discriminator_optimizer,\r\n                 discriminator_optimizer_separate=config.discriminator_optimizer_separate,\r\n                 discriminator_scheduler=config.discriminator_scheduler,\r\n                 discriminator_scheduler_separate=config.discriminator_scheduler_separate,\r\n                 epoch=config.epoch,\r\n                 num_it_epoch=config.num_it_epoch,\r\n                 num_it_total=config.num_it_total,\r\n                 eval_epoch=config.eval_epoch,\r\n                 eval_it=config.eval_it,\r\n                 device=config.device,\r\n                 train_dataset=config.train_dataset,\r\n                 labeled_dataset=config.labeled_dataset,\r\n                 unlabeled_dataset=config.unlabeled_dataset,\r\n                 valid_dataset=config.valid_dataset,\r\n                 test_dataset=config.test_dataset,\r\n                 train_dataloader=config.train_dataloader,\r\n                 labeled_dataloader=config.labeled_dataloader,\r\n                 unlabeled_dataloader=config.unlabeled_dataloader,\r\n                 valid_dataloader=config.valid_dataloader,\r\n                 test_dataloader=config.test_dataloader,\r\n                 train_sampler=config.train_sampler,\r\n                 train_batch_sampler=config.train_batch_sampler,\r\n                 valid_sampler=config.valid_sampler,\r\n                 valid_batch_sampler=config.valid_batch_sampler,\r\n                 test_sampler=config.test_sampler,\r\n                 test_batch_sampler=config.test_batch_sampler,\r\n                 labeled_sampler=config.labeled_sampler,\r\n                 unlabeled_sampler=config.unlabeled_sampler,\r\n                 labeled_batch_sampler=config.labeled_batch_sampler,\r\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\r\n                 augmentation=config.augmentation,\r\n                 network=config.network,\r\n                 optimizer=config.optimizer,\r\n                 scheduler=config.scheduler,\r\n                 evaluation=config.evaluation,\r\n                 parallel=config.parallel,\r\n                 file=config.file,\r\n                 verbose=config.verbose\r\n                 ):\r\n        # >> Parameter:\r\n        # >> - lambda_u: The weight of unsupervised loss.\r\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4,\r\n        #              then warmup is performed in the first 40 iterations.\r\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\r\n                                    valid_dataset=valid_dataset,\r\n                                    test_dataset=test_dataset,\r\n                                    train_dataloader=train_dataloader,\r\n                                    valid_dataloader=valid_dataloader,\r\n                                    test_dataloader=test_dataloader,\r\n                                    augmentation=augmentation,\r\n                                    network=network,\r\n                                    train_sampler=train_sampler,\r\n                                    train_batch_sampler=train_batch_sampler,\r\n                                    valid_sampler=valid_sampler,\r\n                                    valid_batch_sampler=valid_batch_sampler,\r\n                                    test_sampler=test_sampler,\r\n                                    test_batch_sampler=test_batch_sampler,\r\n                                    labeled_dataset=labeled_dataset,\r\n                                    unlabeled_dataset=unlabeled_dataset,\r\n                                    labeled_dataloader=labeled_dataloader,\r\n                                    unlabeled_dataloader=unlabeled_dataloader,\r\n                                    labeled_sampler=labeled_sampler,\r\n                                    unlabeled_sampler=unlabeled_sampler,\r\n                                    labeled_batch_sampler=labeled_batch_sampler,\r\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\r\n                                    epoch=epoch,\r\n                                    num_it_epoch=num_it_epoch,\r\n                                    num_it_total=num_it_total,\r\n                                    eval_epoch=eval_epoch,\r\n                                    eval_it=eval_it,\r\n                                    mu=mu,\r\n                                    weight_decay=weight_decay,\r\n                                    ema_decay=ema_decay,\r\n                                    optimizer=optimizer,\r\n                                    scheduler=scheduler,\r\n                                    device=device,\r\n                                    evaluation=evaluation,\r\n                                    parallel=parallel,\r\n                                    file=file,\r\n                                    verbose=verbose\r\n                                    )\r\n        self.ema_decay=ema_decay\r\n        self.lambda_u=lambda_u\r\n        self.weight_decay=weight_decay\r\n        self.warmup=warmup\r\n        self.adv_warmup=adv_warmup\r\n        self.threshold=threshold\r\n        self.T=T\r\n        self.eps=eps\r\n        self.num_classes=num_classes\r\n        self.discriminator = discriminator\r\n        self.discriminator_separate = discriminator_separate\r\n        self.discriminator_optimizer=discriminator_optimizer\r\n        self.discriminator_optimizer_separate=discriminator_optimizer_separate\r\n        self.discriminator_scheduler=discriminator_scheduler\r\n        self.discriminator_scheduler_separate=discriminator_scheduler_separate\r\n        self.l_domain_temper=l_domain_temper\r\n        self.u_domain_temper=u_domain_temper\r\n        self.l_class_temper=l_class_temper\r\n        self.u_class_temper=u_class_temper\r\n        self._discriminator=copy.deepcopy(discriminator)\r\n        self._discriminator_separate = copy.deepcopy(discriminator_separate)\r\n        self._discriminator_optimizer=copy.deepcopy(discriminator_optimizer)\r\n        self._discriminator_optimizer_separate = copy.deepcopy(discriminator_optimizer_separate)\r\n        self._discriminator_scheduler=copy.deepcopy(discriminator_scheduler)\r\n        self._discriminator_scheduler_separate = copy.deepcopy(discriminator_scheduler_separate)\r\n        self.bn_controller=Bn_Controller()\r\n        self._estimator_type = ClassifierMixin._estimator_type\r\n\r\n    def init_transform(self):\r\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\r\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\r\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\r\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\r\n\r\n    def init_model(self):\r\n        self._network = copy.deepcopy(self.network)\r\n        self._parallel = copy.deepcopy(self.parallel)\r\n        self._discriminator=copy.deepcopy(self.discriminator)\r\n        self._discriminator_separate = copy.deepcopy(self.discriminator_separate)\r\n        if self.device is None:\r\n            self.device='cpu'\r\n        if self.device is not 'cpu':\r\n            torch.cuda.set_device(self.device)\r\n        self._discriminator=self._discriminator.to(self.device)\r\n        self._discriminator_separate=self._discriminator_separate.to(self.device)\r\n        self._network=self._network.to(self.device)\r\n        if self._parallel is not None:\r\n            self._network=self._parallel.init_parallel(self._network)\r\n            self._discriminator=self._parallel.init_parallel(self._discriminator)\r\n            self._discriminator_separate=self._parallel.init_parallel(self._discriminator_separate)\r\n\r\n    def start_fit(self, *args, **kwargs):\r\n        self.init_epoch()\r\n        self._network.zero_grad()\r\n        self._network.train()\r\n        self._discriminator.zero_grad()\r\n        self._discriminator.train()\r\n        self._discriminator_separate.zero_grad()\r\n        self._discriminator_separate.train()\r\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\r\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\r\n        self.l_weight = torch.zeros((len(self._train_dataset.labeled_dataset), 1)).to(self.device)\r\n        self.u_weight = torch.zeros((len(self._train_dataset.unlabeled_dataset), 1)).to(self.device)\r\n        self.class_weight = torch.zeros((self.num_classes, 1)).to(self.device)\r\n        self.label_all = torch.zeros(len(self._train_dataset.labeled_dataset)).to(self.device).long()\r\n        self.beta_distribution = torch.distributions.beta.Beta(0.75, 0.75)\r\n\r\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\r\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\r\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\r\n        w_ulb_X,s_ulb_X=ulb_X[0],ulb_X[1]\r\n        inputs=torch.cat((lb_X, w_ulb_X, s_ulb_X))\r\n        batch_size=lb_X.shape[0]\r\n        features,logits = self._network(inputs)\r\n        lb_logits = logits[:batch_size]\r\n        w_ulb_logits, s_ulb_logits = logits[batch_size:].chunk(2)\r\n        l_feature=features[:batch_size]\r\n        u_feature,_=features[batch_size:].chunk(2)\r\n\r\n        self._network.eval()\r\n        l_pred_shift = compute_score(lb_X.detach(), self._network,self.eps).detach()\r\n        u_pred_shift = compute_score(ulb_X[0].detach(),self._network,self.eps).detach()\r\n        self._network.train()\r\n\r\n        l_domain_prob = self._discriminator.forward(l_feature)\r\n        u_domain_prob = self._discriminator.forward(u_feature)\r\n\r\n        permidx = match_string(lb_y, w_ulb_logits)\r\n\r\n        shuf_u_feature = u_feature[permidx]\r\n        cos_sim = nn.CosineSimilarity(dim=1)(l_feature, shuf_u_feature)\r\n        cos_sim = feature_scaling(cos_sim)\r\n        cos_sim = cos_sim.unsqueeze(1).detach()\r\n        lam = self.beta_distribution.sample().item()\r\n        lam = max(lam, 1 - lam)\r\n\r\n        mix_feature = lam * l_feature + (1 - lam) * shuf_u_feature\r\n\r\n        domain_prob_separate_mix = self._discriminator_separate(mix_feature.detach())\r\n        l_domain_prob_separate = self._discriminator_separate.forward(l_feature.detach())\r\n        u_domain_prob_separate = self._discriminator_separate.forward(u_feature.detach())\r\n\r\n        label_share_weight = get_label_share_weight(\r\n            l_domain_prob_separate, l_pred_shift, domain_temperature=self.l_domain_temper,\r\n            class_temperature=self.l_class_temper)\r\n        label_share_weight = normalize_weight(label_share_weight)\r\n\r\n        unlabel_share_weight = get_unlabel_share_weight(\r\n            u_domain_prob_separate, u_pred_shift, domain_temperature=self.u_domain_temper,\r\n            class_temperature=self.u_class_temper)\r\n        unlabel_share_weight = normalize_weight(unlabel_share_weight)\r\n\r\n        adv_loss = torch.zeros(1).to(self.device)\r\n        adv_loss_separate = torch.zeros(1).to(self.device)\r\n\r\n        tmp = self.l_weight[lb_idx] * nn.BCELoss(reduction=\"none\")(l_domain_prob, torch.zeros_like(l_domain_prob))\r\n        adv_loss += torch.mean(tmp, dim=0)\r\n        tmp = self.u_weight[ulb_idx] * nn.BCELoss(reduction=\"none\")(u_domain_prob, torch.ones_like(u_domain_prob))\r\n        adv_loss += torch.mean(tmp, dim=0)\r\n\r\n        self.l_weight[lb_idx] = label_share_weight\r\n        self.u_weight[ulb_idx] = unlabel_share_weight\r\n        # D'\r\n        # tmp = cos_sim * nn.BCELoss(reduction=\"none\")(domain_prob_separate_mix, torch.ones_like(domain_prob_separate_mix)*(1 - lam))\r\n        tmp = cos_sim * (-1. * (1 - lam) * torch.log(domain_prob_separate_mix) - lam * torch.log(\r\n            1 - domain_prob_separate_mix))\r\n        adv_loss_separate += torch.mean(tmp, dim=0)\r\n        adv_loss_separate += nn.BCELoss()(l_domain_prob_separate, torch.zeros_like(l_domain_prob_separate))\r\n        adv_loss_separate += nn.BCELoss()(u_domain_prob_separate, torch.ones_like(u_domain_prob_separate))\r\n\r\n        if self.it_total  > 100:\r\n            w_ulb_logits = pseudo_label_calibration(w_ulb_logits, self.class_weight)\r\n\r\n        # ramp up exp(-5(1 - t)^2)\r\n        # coef = 1. * math.exp(-5 * (1 - min(self.it_total / (self.warmup*self.num_it_total), 1)) ** 2)\r\n        # pseudo_label = torch.softmax(u_output.detach() / self.T, dim=-1)\r\n        # max_probs, targets_u = torch.max(pseudo_label, dim=-1)\r\n        # mask = max_probs.ge(self.threshold).float()\r\n        # ssl_loss = (Cross_Entropy(reduction='none')(s_u_output, targets_u) * mask).mean()* coef\r\n        pseudo_label = torch.softmax(w_ulb_logits.detach() / self.T, dim=-1)\r\n        max_probs, targets_u = torch.max(pseudo_label, dim=-1)\r\n        mask = max_probs.ge(self.threshold).float()\r\n        ssl_loss = (Cross_Entropy(reduction='none')(s_ulb_logits, targets_u) * mask).mean()*self.lambda_u\r\n        # supervised loss\r\n        cls_loss = Cross_Entropy(reduction='mean')(logits=lb_logits,targets=lb_y)\r\n\r\n        adv_coef = 1. * math.exp(-5 * (1 - min(self.it_total / self.adv_warmup, 1)) ** 2)\r\n        return cls_loss , ssl_loss , adv_coef , adv_loss , adv_loss_separate\r\n\r\n    def init_optimizer(self):\r\n        self._optimizer=copy.deepcopy(self.optimizer)\r\n        self._discriminator_optimizer = copy.deepcopy(self.discriminator_optimizer)\r\n        self._discriminator_optimizer_separate = copy.deepcopy(self.discriminator_optimizer_separate)\r\n        if isinstance(self._optimizer,BaseOptimizer):\r\n            no_decay = ['bias', 'bn']\r\n            grouped_parameters = [\r\n                {'params': [p for n, p in self._network.named_parameters() if not any(\r\n                    nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\r\n                {'params': [p for n, p in self._network.named_parameters() if any(\r\n                    nd in n for nd in no_decay)], 'weight_decay': 0.0}\r\n            ]\r\n            self._optimizer=self._optimizer.init_optimizer(params=grouped_parameters)\r\n\r\n        if isinstance(self._discriminator_optimizer,BaseOptimizer):\r\n            no_decay = ['bias', 'bn']\r\n            grouped_parameters = [\r\n                {'params': [p for n, p in self._discriminator.named_parameters() if not any(\r\n                    nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\r\n                {'params': [p for n, p in self._discriminator.named_parameters() if any(\r\n                    nd in n for nd in no_decay)], 'weight_decay': 0.0}\r\n            ]\r\n            self._discriminator_optimizer=self._discriminator_optimizer.init_optimizer(params=grouped_parameters)\r\n\r\n        if isinstance(self._discriminator_optimizer_separate,BaseOptimizer):\r\n            no_decay = ['bias', 'bn']\r\n            grouped_parameters = [\r\n                {'params': [p for n, p in self._discriminator_separate.named_parameters() if not any(\r\n                    nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\r\n                {'params': [p for n, p in self._discriminator_separate.named_parameters() if any(\r\n                    nd in n for nd in no_decay)], 'weight_decay': 0.0}\r\n            ]\r\n            self._discriminator_optimizer_separate=self._discriminator_optimizer_separate.init_optimizer(params=grouped_parameters)\r\n\r\n    def init_scheduler(self):\r\n        self._scheduler=copy.deepcopy(self.scheduler)\r\n        if isinstance(self._scheduler,BaseScheduler):\r\n            self._scheduler=self._scheduler.init_scheduler(optimizer=self._optimizer)\r\n\r\n        self._discriminator_scheduler=copy.deepcopy(self.discriminator_scheduler)\r\n        if isinstance(self._discriminator_scheduler,BaseScheduler):\r\n            self._discriminator_scheduler=self._discriminator_scheduler.init_scheduler(optimizer=self._discriminator_optimizer)\r\n\r\n        self._discriminator_scheduler_separate=copy.deepcopy(self.discriminator_scheduler_separate)\r\n        if isinstance(self._discriminator_scheduler_separate,BaseScheduler):\r\n            self._discriminator_scheduler_separate=self._discriminator_scheduler_separate.init_scheduler(optimizer=self._discriminator_optimizer_separate)\r\n\r\n\r\n\r\n    def optimize(self,loss,*args,**kwargs):\r\n        self._network.zero_grad()\r\n        self._discriminator.zero_grad()\r\n        self._discriminator_separate.zero_grad()\r\n        loss.backward()\r\n        self._optimizer.step()\r\n        if self._scheduler is not None:\r\n            self._scheduler.step()\r\n        self._discriminator_optimizer.step()\r\n        if self._discriminator_scheduler is not None:\r\n            self._discriminator_scheduler.step()\r\n        self._discriminator_optimizer_separate.step()\r\n        if self._discriminator_scheduler_separate is not None:\r\n            self._discriminator_scheduler_separate.step()\r\n        if self.ema is not None:\r\n            self.ema.update()\r\n\r\n\r\n    def end_fit_epoch(self, *args, **kwargs):\r\n        self.class_weight = compute_class_weight(self.l_weight, self.label_all, self.class_weight)\r\n\r\n    @torch.no_grad()\r\n    def estimate(self, X, idx=None, *args, **kwargs):\r\n        _,outputs = self._network(X)\r\n        return outputs\r\n\r\n\r\n    def get_loss(self,train_result,*args,**kwargs):\r\n        # lb_logits,lb_y,ulb_logits_1,ulb_logits_2=train_result\r\n        # sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)\r\n        # _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\r\n        # unsup_loss = _warmup * Consistency(reduction='mean')(ulb_logits_1,ulb_logits_2.detach())\r\n        # loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss ,unsup_loss)\r\n        cls_loss, ssl_loss, adv_coef, adv_loss, adv_loss_separate=train_result\r\n        loss = cls_loss + ssl_loss + adv_coef * (adv_loss + adv_loss_separate)\r\n        return loss\r\n\r\n    def predict(self,X=None,valid=None):\r\n        return DeepModelMixin.predict(self,X=X,valid=valid)\r\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/Co_Training.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nimport numpy as np\nfrom sklearn.base import ClassifierMixin\nimport random\nimport copy\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.Co_Training as config\nfrom LAMDA_SSL.Split.ViewSplit import ViewSplit\n\n\nclass Co_Training(InductiveEstimator, ClassifierMixin):\n    # Binary\n    def __init__(\n            self,\n            base_estimator=config.base_estimator,\n            base_estimator_2=config.base_estimator_2,\n            p=config.p,\n            n=config.n,\n            k=config.k,\n            s=config.s,\n            random_state=config.random_state,\n            evaluation=config.evaluation,\n            verbose=config.verbose,\n            binary=config.binary,\n            threshold=config.threshold,\n            file=config.file):\n        # >> Parameter:\n        # >> - base_estimator: the first learner for co-training.\n        # >> - base_estimator_2: the second learner for co-training.\n        # >> - p: In each round, each base learner selects at most p positive samples to assign pseudo-labels.\n        # >> - n: In each round, each base learner selects at most n negative samples to assign pseudo-labels.\n        # >> - k: iteration rounds.\n        # >> - s: the size of the buffer pool in each iteration.\n        self.base_estimator = base_estimator\n        self.base_estimator_2 = base_estimator_2\n        self.p = p\n        self.n = n\n        self.k = k\n        self.s = s\n        self.random_state = random_state\n        self.evaluation = evaluation\n        self.binary = binary\n        self.threshold = threshold\n        self.verbose = verbose\n        self.file = file\n        if isinstance(self.base_estimator, (list, tuple)):\n            self.base_estimator, self.base_estimator_2 = self.base_estimator[\n                0], self.base_estimator[1]\n        if self.base_estimator_2 is None:\n            self.base_estimator_2 = copy.deepcopy(self.base_estimator)\n        self.y_pred = None\n        self.y_score = None\n        random.seed(self.random_state)\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self, X, y, unlabeled_X, X_2=None, unlabeled_X_2=None):\n        if X_2 is None:\n            if isinstance(X, (list, tuple)):\n                X, X_2 = X[0], X[1]\n            else:\n                X, X_2 = ViewSplit(X, shuffle=False)\n        if unlabeled_X_2 is None:\n            if isinstance(unlabeled_X, (list, tuple)):\n                unlabeled_X, unlabeled_X_2 = unlabeled_X[0], unlabeled_X[1]\n            else:\n                unlabeled_X, unlabeled_X_2 = ViewSplit(\n                    unlabeled_X, shuffle=False)\n\n        X = copy.copy(X)\n        X_2 = copy.copy(X_2)\n        y = copy.copy(y)\n\n        unlabeled_y = np.ones(len(unlabeled_X)) * -1\n\n        unlabeled_idx = np.arange(len(unlabeled_X))\n\n        random.shuffle(unlabeled_idx)\n\n        selected_unlabeled_idx = unlabeled_idx[-min(\n            len(unlabeled_idx), self.s):]\n\n        unlabeled_idx = unlabeled_idx[:-len(selected_unlabeled_idx)]\n\n        it = 0\n\n        while it != self.k and len(unlabeled_idx):\n            it += 1\n\n            self.base_estimator.fit(X, y)\n            self.base_estimator_2.fit(X_2, y)\n\n            proba_1 = self.base_estimator.predict_proba(\n                unlabeled_X[selected_unlabeled_idx])\n            proba_2 = self.base_estimator_2.predict_proba(\n                unlabeled_X_2[selected_unlabeled_idx])\n            if self.binary:\n                negative_samples, positive_samples = [], []\n\n                for i in (proba_1[:, 0].argsort())[-self.n:]:\n                    if proba_1[i, 0] > self.threshold:\n                        negative_samples.append(i)\n                for i in (proba_1[:, 1].argsort())[-self.p:]:\n                    if proba_1[i, 1] > self.threshold:\n                        positive_samples.append(i)\n\n                for i in (proba_2[:, 0].argsort())[-self.n:]:\n                    if proba_2[i, 0] > self.threshold:\n                        negative_samples.append(i)\n                for i in (proba_2[:, 1].argsort())[-self.p:]:\n                    if proba_2[i, 1] > self.threshold:\n                        positive_samples.append(i)\n                unlabeled_y[[selected_unlabeled_idx[x]\n                             for x in positive_samples]] = 1\n                unlabeled_y[[selected_unlabeled_idx[x]\n                             for x in negative_samples]] = 0\n\n                for x in positive_samples:\n                    X = np.vstack([X, unlabeled_X[selected_unlabeled_idx[x]]])\n                    X_2 = np.vstack(\n                        [X_2, unlabeled_X_2[selected_unlabeled_idx[x]]])\n                    y = np.hstack([y, unlabeled_y[selected_unlabeled_idx[x]]])\n\n                for x in negative_samples:\n                    X = np.vstack([X, unlabeled_X[selected_unlabeled_idx[x]]])\n                    X_2 = np.vstack(\n                        [X_2, unlabeled_X_2[selected_unlabeled_idx[x]]])\n                    y = np.hstack([y, unlabeled_y[selected_unlabeled_idx[x]]])\n\n                selected_unlabeled_idx = np.array([elem for elem in selected_unlabeled_idx if not (\n                    elem in positive_samples or elem in negative_samples)])\n                num_selected = len(positive_samples) + len(negative_samples)\n\n            else:\n                pred_1 = np.argmax(proba_1, axis=1)\n                pred_2 = np.argmax(proba_2, axis=1)\n                confidence_1 = np.max(proba_1, axis=1)\n                confidence_2 = np.max(proba_2, axis=1)\n                selected_1 = confidence_1 > self.threshold\n                selected_2 = confidence_2 > self.threshold\n                unlabeled_y[selected_unlabeled_idx[selected_1]] = pred_1[selected_1]\n                unlabeled_y[selected_unlabeled_idx[selected_2]] = pred_2[selected_2]\n                selected_samples=[]\n                for i in (confidence_1.argsort())[-self.n:]:\n                    if confidence_1[i] > self.threshold:\n                        selected_samples.append(i)\n                for i in (confidence_2.argsort())[-self.n:]:\n                    if confidence_2[i] > self.threshold:\n                        selected_samples.append(i)\n                for x in selected_samples:\n                    X = np.vstack([X, unlabeled_X[selected_unlabeled_idx[x]]])\n                    X_2 = np.vstack(\n                        [X_2, unlabeled_X_2[selected_unlabeled_idx[x]]])\n                    y = np.hstack([y, unlabeled_y[selected_unlabeled_idx[x]]])\n                selected_unlabeled_idx = np.array(\n                    [elem for elem in selected_unlabeled_idx if not (elem in selected_samples)])\n                num_selected = len(selected_samples)\n            num_selected = min(num_selected, len(unlabeled_idx))\n            selected_unlabeled_idx = np.concatenate(\n                (selected_unlabeled_idx, unlabeled_idx[:num_selected]))\n            unlabeled_idx = unlabeled_idx[num_selected:]\n\n        self.base_estimator.fit(X, y)\n        self.base_estimator_2.fit(X_2, y)\n        return self\n\n    def predict(self, X, X_2=None):\n        y_proba = self.predict_proba(X=X, X_2=X_2)\n        y_pred = np.argmax(y_proba, axis=1)\n        return y_pred\n\n    def predict_proba(self, X, X_2=None):\n        if X_2 is None:\n            if isinstance(X, (list, tuple)):\n                X, X_2 = X[0], X[1]\n            else:\n                X, X_2 = ViewSplit(X, shuffle=False)\n        # y_proba = np.full((X.shape[0], 2), -1, np.float)\n\n        y1_proba = self.base_estimator.predict_proba(X)\n        y2_proba = self.base_estimator_2.predict_proba(X_2)\n\n        # for i, (y1_i_dist, y2_i_dist) in enumerate(zip(y1_proba, y2_proba)):\n        #     y_proba[i][0] = (y1_i_dist[0] + y2_i_dist[0]) / 2\n        #     y_proba[i][1] = (y1_i_dist[1] + y2_i_dist[1]) / 2\n        y_proba=(y1_proba+y2_proba)/2\n        return y_proba\n\n    def evaluate(self, X, y=None):\n\n        if isinstance(X, Dataset) and y is None:\n            y = getattr(X, 'y')\n\n        self.y_score = self.predict_proba(X)\n        self.y_pred = self.predict(X)\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation, (list, tuple)):\n            performance = []\n            for eval in self.evaluation:\n                score = eval.scoring(y, self.y_pred, self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation, dict):\n            performance = {}\n            for key, val in self.evaluation.items():\n\n                performance[key] = val.scoring(y, self.y_pred, self.y_score)\n\n                if self.verbose:\n                    print(key, ' ', performance[key], file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance = self.evaluation.scoring(y, self.y_pred, self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance = performance\n            return performance\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/FixMatch.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Config.FixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\n\nimport torch\n\nclass FixMatch(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n\n        # >> Parameter:\n        # >> - threshold: The confidence threshold for choosing samples.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature.\n        # >> - num_classes: The number of classes for the classification task.\n        # >> - thresh_warmup: Whether to use threshold warm-up mechanism.\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n        # >> - use_DA: Whether to perform distribution alignment for soft labels.\n        # >> - p_target: p(y) based on the labeled examples seen during training.\n\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.lambda_u=lambda_u\n        self.threshold=threshold\n        self.T=T\n        self.weight_decay=weight_decay\n        self._estimator_type=ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        w_ulb_X,s_ulb_X=ulb_X[0],ulb_X[1]\n        batch_size = lb_X.shape[0]\n        inputs=torch.cat((lb_X, w_ulb_X, s_ulb_X))\n        logits = self._network(inputs)\n        lb_logits = logits[:batch_size]\n        w_ulb_logits, s_ulb_logits = logits[batch_size:].chunk(2)\n        train_result=(lb_logits,lb_y,w_ulb_logits, s_ulb_logits)\n        return train_result\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits, lb_y, w_ulb_logits, s_ulb_logits = train_result\n        sup_loss=Cross_Entropy(reduction='mean')(logits=lb_logits,targets=lb_y)\n        pseudo_label = torch.softmax(w_ulb_logits.detach() / self.T, dim=-1)\n        max_probs, targets_u = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold).float()\n        unsup_loss = (Cross_Entropy(reduction='none')(s_ulb_logits, targets_u) * mask).mean()\n        loss=Semi_Supervised_Loss(lambda_u =self.lambda_u)(sup_loss,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/Fix_A_Step.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Config.FixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nfrom LAMDA_SSL.utils import class_status\nimport torch\nimport torch.nn.functional as F\nimport numpy as np\n\ndef interleave(x, size):\n    s = list(x.shape)\n    return x.reshape([-1, size] + s[1:]).transpose(0, 1).reshape([-1] + s[1:])\n\n\ndef de_interleave(x, size):\n    s = list(x.shape)\n    return x.reshape([size, -1] + s[1:]).transpose(0, 1).reshape([-1] + s[1:])\n\nclass Fix_A_Step(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n    \t\t\t num_classes=None,\n    \t\t\t warmup=0,\n    \t\t\t alpha=0.75,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n\n        # >> Parameter:\n        # >> - threshold: The confidence threshold for choosing samples.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature.\n        # >> - num_classes: The number of classes for the classification task.\n        # >> - thresh_warmup: Whether to use threshold warm-up mechanism.\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n        # >> - use_DA: Whether to perform distribution alignment for soft labels.\n        # >> - p_target: p(y) based on the labeled examples seen during training.\n\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.lambda_u=lambda_u\n        self.alpha=alpha\n        self.warmup=warmup\n        self.threshold=threshold\n        self.num_classes=num_classes\n        self.T=T\n        self.weight_decay=weight_decay\n        self._estimator_type=ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=2)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=2,y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self._network.zero_grad()\n        self._network.train()\n        \n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        w_ulb_X_1, w_ulb_X_2, s_ulb_X=ulb_X[0],ulb_X[1],ulb_X[2]\n        batch_size = lb_X.shape[0]\n        with torch.no_grad():\n            u_output1 = self._network(w_ulb_X_1)\n            u_output2 = self._network(w_ulb_X_2)\n            p = (torch.softmax(u_output1, dim=1) + torch.softmax(u_output2, dim=1)) / 2\n            pt = p**(1/self.T)\n            u_targets = pt/pt.sum(dim=1, keepdim=True)\n            u_targets = u_targets.detach()\n        lb_y = torch.zeros(batch_size, self.num_classes).to(self.device).scatter_(1, lb_y.view(-1,1).long(), 1)\n        Augment_combined_inputs = torch.cat([lb_X, w_ulb_X_1, w_ulb_X_2], dim=0)\n        Augment_combined_labels = torch.cat([lb_y, u_targets, u_targets], dim=0)\n        \n        l = np.random.beta(self.alpha, self.alpha)\n        l = max(l, 1-l)\n        \n        idx = torch.randperm(Augment_combined_inputs.size(0))\n\n        input_a, input_b = Augment_combined_inputs, Augment_combined_inputs[idx]\n        target_a, target_b = Augment_combined_labels, Augment_combined_labels[idx]\n        \n        mixed_input = l * input_a + (1-l) * input_b        \n        mixed_target = l * target_a + (1-l) * target_b\n        \n        mixed_labeled_input = torch.split(mixed_input, batch_size)[0]\n        mixed_labeled_target = torch.split(mixed_target, batch_size)[0]        \n        \n        inputs = interleave(torch.cat((mixed_labeled_input, w_ulb_X_1, s_ulb_X)), 2*self.mu+1).to(self.device)\n        \n        logits = self._network(inputs)\n        logits = de_interleave(logits, 2*self.mu+1)\n        logits_x = logits[:batch_size]\n        logits_u_w, logits_u_s = logits[batch_size:].chunk(2)\n        \n        del logits\n        \n        labeledtrain_loss = -torch.mean(torch.sum(F.log_softmax(logits_x, dim=1) * mixed_labeled_target, dim=1))\n\n        labeledtrain_loss.backward(retain_graph=True)\n\n        labeled_grads = []\n        for name, param in self._network.named_parameters():\n            try:\n                labeled_grads.append(param.grad.view(-1))\n            except:\n                continue\n            \n        labeled_grads = torch.cat(labeled_grads)\n# \n        self._network.zero_grad()\n        \n        pseudo_label = torch.softmax(logits_u_w.detach()/self.T, dim=-1)\n        max_probs, targets_u = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold).float()\n        \n        unlabeledtrain_loss = (F.cross_entropy(logits_u_s, targets_u, reduction='none') * mask).mean()\n        unlabeledtrain_loss.backward(retain_graph=True)\n\n        unlabeled_grads = []\n        for name, param in self._network.named_parameters():\n            try:\n                unlabeled_grads.append(param.grad.view(-1))\n            except:\n                continue\n                \n            \n        unlabeled_grads = torch.cat(unlabeled_grads)\n\n        self._network.zero_grad()\n        \n        gradient_dot = torch.dot(labeled_grads, unlabeled_grads)\n\n\n        current_lambda_u = self.lambda_u\n        \n\n        if self.it_total>= float(self.warmup*self.num_it_total):\n            if gradient_dot<0:\n                # gradient_dot_sign_prob.update(-1)\n                # gradient_dot_sign_this_epoch.append(-1)\n                loss = labeledtrain_loss\n            else:\n                # gradient_dot_sign_prob.update(1)\n                # gradient_dot_sign_this_epoch.append(1)\n                loss = labeledtrain_loss + current_lambda_u * unlabeledtrain_loss\n        else:\n            loss = labeledtrain_loss + current_lambda_u * unlabeledtrain_loss\n        return loss\n\n    def get_loss(self,train_result,*args,**kwargs):\n        loss = train_result\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/FlexMatch.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nfrom collections import Counter\nfrom LAMDA_SSL.utils import class_status\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nimport LAMDA_SSL.Config.FlexMatch as config\nimport torch\n\nclass FlexMatch(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 num_classes=config.num_classes,\n                 threshold_warmup=config.threshold_warmup,\n                 use_hard_labels=config.use_hard_labels,\n                 use_DA=config.use_DA,\n                 p_target=config.p_target,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - threshold: The confidence threshold for choosing samples.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature.\n        # >> - num_classes: The number of classes for the classification task.\n        # >> - thresh_warmup: Whether to use threshold warm-up mechanism.\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n        # >> - use_DA: Whether to perform distribution alignment for soft labels.\n        # >> - p_target: p(y) based on the labeled examples seen during training\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    parallel=parallel,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n\n        self.lambda_u=lambda_u\n        self.threshold=threshold\n        self.T=T\n        self.num_classes=num_classes\n        self.classwise_acc=None\n        self.selected_label=None\n        self.threshold_warmup=threshold_warmup\n        self.use_hard_labels=use_hard_labels\n        self.p_model=None\n        self.p_target=p_target\n        self.use_DA=use_DA\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        if self.p_target is None:\n            class_counts=torch.Tensor(class_status(self._train_dataset.labeled_dataset.y).class_counts).to(self.device)\n            self.p_target = (class_counts / class_counts.sum(dim=-1, keepdim=True))\n        else:\n            self.p_target=self.p_target.to(self.device)\n        self.selected_label = torch.ones((len(self._train_dataset.unlabeled_dataset),), dtype=torch.long ) * -1\n        self.selected_label = self.selected_label.to(self.device)\n        self.classwise_acc = torch.zeros((self.num_classes)).to(self.device)\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        w_ulb_X,s_ulb_X=ulb_X[0],ulb_X[1]\n        num_lb = lb_X.shape[0]\n        pseudo_counter = Counter(self.selected_label.tolist())\n        if max(pseudo_counter.values()) < len(self._train_dataset.unlabeled_dataset):  # not all -1\n            if self.threshold_warmup:\n                for i in range(self.num_classes):\n                    self.classwise_acc[i] = pseudo_counter[i] / max(pseudo_counter.values())\n            else:\n                pseudo_counter_without_negative_1 = copy.deepcopy(pseudo_counter)\n                if -1 in pseudo_counter_without_negative_1.keys():\n                    pseudo_counter_without_negative_1.pop(-1)\n                for i in range(self.num_classes):\n                    self.classwise_acc[i] = pseudo_counter[i] / max(pseudo_counter_without_negative_1.values())\n\n        inputs = torch.cat((lb_X, w_ulb_X, s_ulb_X))\n        logits = self._network(inputs)\n        lb_logits = logits[:num_lb]\n        w_ulb_logits , s_ulb_logits = logits[num_lb:].chunk(2)\n        w_ulb_logits = w_ulb_logits.detach()\n        pseudo_label = torch.softmax(w_ulb_logits, dim=-1)\n        if self.use_DA:\n            if self.p_model == None:\n                self.p_model = torch.mean(pseudo_label.detach(), dim=0)\n            else:\n                self.p_model = self.p_model * 0.999 + torch.mean(pseudo_label.detach(), dim=0) * 0.001\n            pseudo_label = pseudo_label * self.p_target / self.p_model\n            pseudo_label = (pseudo_label / pseudo_label.sum(dim=-1, keepdim=True))\n        max_probs, max_idx = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold * (self.classwise_acc[max_idx] / (2. - self.classwise_acc[max_idx]))).float()\n        select = max_probs.ge(self.threshold ).long()\n        if ulb_idx[select == 1].nelement() != 0:\n            self.selected_label[ulb_idx[select == 1]] = max_idx.long()[select == 1]\n        if self.use_hard_labels is not True:\n            pseudo_label = torch.softmax(w_ulb_logits / self.T, dim=-1)\n        else:\n            pseudo_label=max_idx\n\n        result=(lb_logits,lb_y,s_ulb_logits,pseudo_label,mask)\n        return result\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,s_ulb_logits,pseudo_label,mask = train_result\n        sup_loss=Cross_Entropy(reduction='mean')(logits=lb_logits,targets=lb_y)\n        unsup_loss =(Cross_Entropy(reduction='none',use_hard_labels=self.use_hard_labels)(s_ulb_logits, pseudo_label) * mask).mean()\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss ,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/FreeMatch.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Config.FixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nfrom LAMDA_SSL.utils import class_status\n\nimport torch\n\nclass FreeMatch(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 ema_p=0.999,\n                 use_DA=False,\n                 num_classes=None,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n\n        # >> Parameter:\n        # >> - threshold: The confidence threshold for choosing samples.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature.\n        # >> - num_classes: The number of classes for the classification task.\n        # >> - thresh_warmup: Whether to use threshold warm-up mechanism.\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n        # >> - use_DA: Whether to perform distribution alignment for soft labels.\n        # >> - p_target: p(y) based on the labeled examples seen during training.\n\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.num_classes=num_classes\n        self.ema_p=ema_p\n        self.use_DA=use_DA\n        self.lambda_u=lambda_u\n        self.threshold=threshold\n        self.T=T\n        self.weight_decay=weight_decay\n        self._estimator_type=ClassifierMixin._estimator_type\n    \n    @torch.no_grad()\n    def update_prob_t(self, lb_probs, ulb_probs):\n        ulb_prob_t = ulb_probs.mean(0)\n        self.ulb_prob_t = self.ema_p * self.ulb_prob_t + (1 - self.ema_p) * ulb_prob_t\n\n        lb_prob_t = lb_probs.mean(0)\n        self.lb_prob_t = self.ema_p * self.lb_prob_t + (1 - self.ema_p) * lb_prob_t\n\n        max_probs, max_idx = ulb_probs.max(dim=-1)\n        prob_max_mu_t = torch.mean(max_probs)\n        prob_max_var_t = torch.var(max_probs, unbiased=True)\n        self.prob_max_mu_t = self.ema_p * self.prob_max_mu_t + (1 - self.ema_p) * prob_max_mu_t.item()\n        self.prob_max_var_t = self.ema_p * self.prob_max_var_t + (1 - self.ema_p) * prob_max_var_t.item()\n    \n    @torch.no_grad()\n    def calculate_mask(self, probs):\n        max_probs, max_idx = probs.max(dim=-1)\n        mu = self.prob_max_mu_t\n        var = self.prob_max_var_t\n        mask = torch.exp(-((torch.clamp(max_probs - mu, max=0.0) ** 2) / (2 * var / 4)))\n        return mask.detach(), max_idx.detach()\n    \n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self.p_model = (torch.ones(self.num_classes) / self.num_classes).to(self.device)\n        self.label_hist = (torch.ones(self.num_classes) / self.num_classes).to(self.device) \n        self.time_p = self.p_model.mean()\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        w_ulb_X,s_ulb_X=ulb_X[0],ulb_X[1]\n        batch_size = lb_X.shape[0]\n        inputs=torch.cat((lb_X, w_ulb_X, s_ulb_X))\n        logits = self._network(inputs)\n        lb_logits = logits[:batch_size]\n        w_ulb_logits, s_ulb_logits = logits[batch_size:].chunk(2)\n        train_result=(lb_logits,lb_y,w_ulb_logits, s_ulb_logits)\n        return train_result\n\n    @torch.no_grad()\n    def distribution_alignment(self, probs):\n        # da\n        probs = probs * self.lb_prob_t / self.ulb_prob_t\n        probs = probs / probs.sum(dim=1, keepdim=True)\n        return probs.detach()\n\n    def cal_time_p_and_p_model(self,logits_x_ulb_w, time_p, p_model, label_hist):\n        prob_w = torch.softmax(logits_x_ulb_w, dim=1) \n        max_probs, max_idx = torch.max(prob_w, dim=-1)\n        if time_p is None:\n            time_p = max_probs.mean()\n        else:\n            time_p = time_p * 0.999 +  max_probs.mean() * 0.001\n        if p_model is None:\n            p_model = torch.mean(prob_w, dim=0)\n        else:\n            p_model = p_model * 0.999 + torch.mean(prob_w, dim=0) * 0.001\n        if label_hist is None:\n            label_hist = torch.bincount(max_idx, minlength=p_model.shape[0]).to(p_model.dtype) \n            label_hist = label_hist / label_hist.sum()\n        else:\n            hist = torch.bincount(max_idx, minlength=p_model.shape[0]).to(p_model.dtype) \n            label_hist = label_hist * 0.999 + (hist / hist.sum()) * 0.001\n        return time_p,p_model,label_hist\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits, lb_y, w_ulb_logits, s_ulb_logits = train_result\n        probs_x_lb = torch.softmax(lb_logits.detach(), dim=-1)\n        sup_loss=Cross_Entropy(reduction='mean')(logits=lb_logits,targets=lb_y)\n        self.time_p, self.p_model, self.label_hist = self.cal_time_p_and_p_model(w_ulb_logits, self.time_p, self.p_model, self.label_hist)\n        pseudo_label = torch.softmax(w_ulb_logits.detach(), dim=-1)\n        max_probs, max_idx = torch.max(pseudo_label, dim=-1)\n        p_cutoff = self.time_p\n        p_model_cutoff = self.p_model / torch.max(self.p_model,dim=-1)[0]\n        threshold = p_cutoff * p_model_cutoff[max_idx]\n        mask = max_probs.ge(threshold)\n\n        # mask, targets_u= self.calculate_mask(probs_x_ulb_w)\n        \n        # pseudo_label = torch.softmax(w_ulb_logits.detach() / self.T, dim=-1)\n        # max_probs, targets_u = torch.max(pseudo_label, dim=-1)\n        # mask = max_probs.ge(self.threshold).float()\n        unsup_loss = (Cross_Entropy(reduction='none')(s_ulb_logits, max_idx) * mask).mean()\n        loss=Semi_Supervised_Loss(lambda_u =self.lambda_u)(sup_loss,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/GAT.py",
    "content": "import copy\n\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nimport LAMDA_SSL.Network.GAT as GATNET\nfrom torch.utils.data.dataset import Dataset\nfrom torch_geometric.data.data import Data\nimport torch\nfrom LAMDA_SSL.utils import class_status\nimport LAMDA_SSL.Config.GAT as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\n\nclass GAT(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 dim_in=config.dim_in,\n                 dim_hidden=config.dim_hidden,\n                 dropout=config.dropout,\n                 heads=config.heads,\n                 num_classes=config.num_classes,\n                 epoch=config.epoch,\n                 eval_epoch=config.eval_epoch,\n                 optimizer=config.optimizer,\n                 weight_decay=config.weight_decay,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 evaluation=config.evaluation,\n                 network=config.network,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - dim_in: Node feature dimension.\n        # >> - dim_hidden: the dimension of hidden layers.\n        # >> - num_classes: Number of classes.\n        # >> - dropout: The dropout rate.\n        # >> - heads: The number of heads.\n        DeepModelMixin.__init__(self,\n                                    epoch=epoch,\n                                    weight_decay=weight_decay,\n                                    network=network,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    eval_epoch=eval_epoch,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.dim_in=dim_in\n        self.dim_hidden=dim_hidden\n        self.heads=heads\n        self.dropout=dropout\n        self.num_classes=num_classes\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self,X=None,y=None,unlabeled_X=None,valid_X=None,valid_y=None,\n            edge_index=None,train_mask=None,labeled_mask=None,unlabeled_mask=None,valid_mask=None,test_mask=None):\n        self.init_train_dataset(X,y,unlabeled_X,edge_index,train_mask,labeled_mask,unlabeled_mask,valid_mask,test_mask)\n        self.init_train_dataloader()\n        self.start_fit()\n        self.fit_epoch_loop(valid_X,valid_y)\n        self.end_fit()\n        return self\n\n    def start_fit(self):\n        self.dim_in = self.data.x.shape[1] if self.dim_in is None else self.dim_in\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self.data.y).num_classes\n        if self.network is None:\n            self.network=GATNET.GAT(dim_in=self.dim_in,dim_hidden=self.dim_hidden,\n                                    heads=self.heads,dropout=self.dropout,num_classes=self.num_classes)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def init_optimizer(self):\n        self._optimizer = copy.deepcopy(self.optimizer)\n        if isinstance(self._optimizer,BaseOptimizer):\n            grouped_parameters=[\n                dict(params=self._network.conv1.parameters(), weight_decay=self.weight_decay),\n                dict(params=self._network.conv2.parameters(), weight_decay=0)\n            ]\n            self._optimizer=self._optimizer.init_optimizer(params=grouped_parameters)\n\n    def init_train_dataloader(self):\n        pass\n\n    def init_train_dataset(self, X=None, y=None, unlabeled_X=None,\n                           edge_index=None,train_mask=None,labeled_mask=None,\n                           unlabeled_mask=None,val_mask=None,test_mask=None):\n        self._train_dataset = copy.deepcopy(self.train_dataset)\n        if isinstance(X,Dataset):\n            X=X.data\n        if not isinstance(X,Data):\n            if not isinstance(X, torch.Tensor):\n                X = torch.Tensor(X)\n            if not isinstance(y, torch.Tensor):\n                y = torch.LongTensor(y)\n            if unlabeled_X is not None and not isinstance(unlabeled_X, torch.Tensor):\n                unlabeled_X = torch.Tensor(unlabeled_X)\n            if not isinstance(edge_index, torch.Tensor):\n                edge_index = torch.LongTensor(edge_index)\n            if not isinstance(train_mask, torch.Tensor):\n                train_mask = torch.BoolTensor(train_mask)\n            if not isinstance(labeled_mask, torch.Tensor):\n                labeled_mask = torch.BoolTensor(labeled_mask)\n            if not isinstance(unlabeled_mask, torch.Tensor):\n                unlabeled_mask = torch.BoolTensor(unlabeled_mask)\n            if not isinstance(val_mask, torch.Tensor):\n                val_mask = torch.BoolTensor(val_mask)\n            if not isinstance(val_mask, torch.Tensor):\n                test_mask = torch.BoolTensor(test_mask)\n\n            if unlabeled_X is not None:\n                X = torch.cat((X, unlabeled_X), dim=0)\n                unlabeled_y = torch.ones(unlabeled_X.shape[0]) * -1\n                y = torch.cat((y, unlabeled_y), dim=0)\n\n            X=Data(x=X,y=y,edge_index=edge_index,train_mask=train_mask,labeled_mask=labeled_mask,\n                   unlabeled_mask=unlabeled_mask,val_mask=val_mask,test_mask=test_mask)\n        self.data=X.to(self.device)\n        self.train_mask = self.data.train_mask.to(self.device) if hasattr(self.data, 'train_mask') else None\n        self.labeled_mask = self.data.labeled_mask.to(self.device) if hasattr(self.data,'labeled_mask') else None\n        self.unlabeled_mask = self.data.unlabeled_mask.to(self.device) if hasattr(self.data,'unlabeled_mask') else None\n        self.valid_mask = self.data.val_mask.to(self.device) if hasattr(self.data, 'val_mask') else None\n        self.test_mask = self.data.test_mask.to(self.device) if hasattr(self.data, 'test_mask') else None\n\n\n    def end_fit_epoch(self, train_result,*args, **kwargs):\n        self.loss = self.get_loss(train_result)\n        self.optimize(self.loss)\n\n    def fit_epoch_loop(self, valid_X=None, valid_y=None):\n        self.valid_performance = {}\n        self.data=self.data.to(self.device)\n        if valid_X is None:\n            valid_X=self.data.val_mask\n\n        for self._epoch in range(1,self.epoch+1):\n            if self.verbose:\n                print(self._epoch,file=self.file)\n            train_performance  = self.train(lb_X=self.data.labeled_mask)\n\n            self.end_fit_epoch(train_performance)\n\n            if valid_X is not None and self.eval_epoch is not None and self._epoch % self.eval_epoch==0:\n                self.evaluate(X=valid_X,y=valid_y,valid=True)\n                self.valid_performance.update({\"epoch_\" + str(self._epoch): self.performance })\n\n        if valid_X is not None and (self.eval_epoch is None or self.epoch% self.eval_epoch!=0):\n            self.evaluate(X=valid_X, y=valid_y, valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch): self.performance})\n\n    def train(self, lb_X=None, lb_y=None, ulb_X=None, lb_idx=None, ulb_idx=None, *args, **kwargs):\n        self.logits = self._network(self.data)\n        lb_logits = self.logits[lb_X]\n        lb_y=self.data.y[lb_X]\n        return lb_logits,lb_y\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits, lb_y=train_result\n        loss=Cross_Entropy(reduction='mean')(lb_logits,lb_y)\n        return loss\n\n\n    def init_estimate_dataloader(self,valid=False):\n        pass\n\n    def init_estimate_dataset(self, X=None, valid=False):\n        if X is not None and not isinstance(X, torch.Tensor):\n            X = torch.BoolTensor(X).to(self.device)\n        if valid:\n            self.pred_mask = X if X is not None else self.data.val_mask\n        else:\n            self.pred_mask = X if X is not None else self.data.test_mask\n\n    def predict_batch_loop(self):\n        with torch.no_grad():\n            self.y_est=self.logits[self.pred_mask]\n\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n    @torch.no_grad()\n    def evaluate(self,X=None,y=None,valid=False):\n        y_pred=self.predict(X,valid=valid)\n        y_score=self.y_score\n        y =self.data.y[X].cpu().detach().numpy() if y is None else y\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance =[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,y_pred,y_score)\n                if self.verbose:\n                    print(score,file=self.file)\n                performance .append(score)\n            self.performance =performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance ={}\n            for key,val in self.evaluation.items():\n                performance [key]=val.scoring(y,y_pred,y_score)\n                if self.verbose:\n                    print(key,' ',performance [key],file=self.file)\n            self.performance  = performance\n            return performance\n        else:\n            performance =self.evaluation.scoring(y,y_pred,y_score)\n            if self.verbose:\n                print(performance ,file=self.file)\n            self.performance  = performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/GCN.py",
    "content": "import copy\n\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nimport LAMDA_SSL.Network.GCN as GCNNET\nfrom torch.utils.data.dataset import Dataset\nfrom torch_geometric.data.data import Data\nimport torch\nfrom LAMDA_SSL.utils import class_status\nimport LAMDA_SSL.Config.GCN as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\n\nclass GCN(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 dim_in=config.dim_in,\n                 dim_hidden=config.dim_hidden,\n                 num_classes=config.num_classes,\n                 normalize=config.normalize,\n                 epoch=config.epoch,\n                 eval_epoch=config.eval_epoch,\n                 optimizer=config.optimizer,\n                 weight_decay=config.weight_decay,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 evaluation=config.evaluation,\n                 network=config.network,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - dim_in: Node feature dimension.\n        # >> - dim_hidden: the dimension of hidden layers.\n        # >> - num_classes: Number of classes.\n        # >> - normalize: Whether to use symmetric normalization.\n        DeepModelMixin.__init__(self,\n                                    epoch=epoch,\n                                    weight_decay=weight_decay,\n                                    network=network,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    eval_epoch=eval_epoch,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.normalize=normalize\n        self.dim_in=dim_in\n        self.dim_hidden=dim_hidden\n        self.num_classes=num_classes\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self,X=None,y=None,unlabeled_X=None,valid_X=None,valid_y=None,\n            edge_index=None,train_mask=None,labeled_mask=None,unlabeled_mask=None,valid_mask=None,test_mask=None):\n        self.init_train_dataset(X,y,unlabeled_X,edge_index,train_mask,labeled_mask,unlabeled_mask,valid_mask,test_mask)\n        self.init_train_dataloader()\n        self.start_fit()\n        self.fit_epoch_loop(valid_X,valid_y)\n        self.end_fit()\n        return self\n\n    def start_fit(self):\n        self.num_features= self.data.x.shape[1] if self.dim_in is None else self.dim_in\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self.data.y).num_classes\n        if self.network is None:\n            self.network=GCNNET.GCN(dim_in=self.dim_in,dim_hidden=self.dim_hidden,\n                                    num_classes=self.num_classes,normalize=self.normalize)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def init_optimizer(self):\n        self._optimizer = copy.deepcopy(self.optimizer)\n        if isinstance(self._optimizer,BaseOptimizer):\n            grouped_parameters=[\n                dict(params=self._network.conv1.parameters(), weight_decay=self.weight_decay),\n                dict(params=self._network.conv2.parameters(), weight_decay=0)\n            ]\n            self._optimizer=self._optimizer.init_optimizer(params=grouped_parameters)\n\n    def init_train_dataloader(self):\n        pass\n\n    def init_train_dataset(self, X=None, y=None, unlabeled_X=None,\n                           edge_index=None,train_mask=None,labeled_mask=None,\n                           unlabeled_mask=None,val_mask=None,test_mask=None):\n        self._train_dataset = copy.deepcopy(self.train_dataset)\n        if isinstance(X,Dataset):\n            X=X.data\n        if not isinstance(X,Data):\n            if not isinstance(X, torch.Tensor):\n                X = torch.Tensor(X)\n            if not isinstance(y, torch.Tensor):\n                y = torch.LongTensor(y)\n            if unlabeled_X is not None and not isinstance(unlabeled_X, torch.Tensor):\n                unlabeled_X = torch.Tensor(unlabeled_X)\n            if not isinstance(edge_index, torch.Tensor):\n                edge_index = torch.LongTensor(edge_index)\n            if not isinstance(train_mask, torch.Tensor):\n                train_mask = torch.BoolTensor(train_mask)\n            if not isinstance(labeled_mask, torch.Tensor):\n                labeled_mask = torch.BoolTensor(labeled_mask)\n            if not isinstance(unlabeled_mask, torch.Tensor):\n                unlabeled_mask = torch.BoolTensor(unlabeled_mask)\n            if not isinstance(val_mask, torch.Tensor):\n                val_mask = torch.BoolTensor(val_mask)\n            if not isinstance(val_mask, torch.Tensor):\n                test_mask = torch.BoolTensor(test_mask)\n\n            if unlabeled_X is not None:\n                X = torch.cat((X, unlabeled_X), dim=0)\n                unlabeled_y = torch.ones(unlabeled_X.shape[0]) * -1\n                y = torch.cat((y, unlabeled_y), dim=0)\n\n            X=Data(x=X,y=y,edge_index=edge_index,train_mask=train_mask,labeled_mask=labeled_mask,\n                   unlabeled_mask=unlabeled_mask,val_mask=val_mask,test_mask=test_mask)\n        self.data=X.to(self.device)\n        self.train_mask = self.data.train_mask.to(self.device) if hasattr(self.data, 'train_mask') else None\n        self.labeled_mask = self.data.labeled_mask.to(self.device) if hasattr(self.data,'labeled_mask') else None\n        self.unlabeled_mask = self.data.unlabeled_mask.to(self.device) if hasattr(self.data,'unlabeled_mask') else None\n        self.valid_mask = self.data.val_mask.to(self.device) if hasattr(self.data, 'val_mask') else None\n        self.test_mask = self.data.test_mask.to(self.device) if hasattr(self.data, 'test_mask') else None\n\n\n    def end_fit_epoch(self, train_result,*args, **kwargs):\n        self.loss = self.get_loss(train_result)\n        self.optimize(self.loss)\n\n    def fit_epoch_loop(self, valid_X=None, valid_y=None):\n        self.valid_performance = {}\n        self.data=self.data.to(self.device)\n        if valid_X is None:\n            valid_X=self.data.val_mask\n\n        for self._epoch in range(1,self.epoch+1):\n            if self.verbose:\n                print(self._epoch,file=self.file)\n            train_performance  = self.train(lb_X=self.data.labeled_mask)\n\n            self.end_fit_epoch(train_performance)\n\n            if valid_X is not None and self.eval_epoch is not None and self._epoch % self.eval_epoch==0:\n                self.evaluate(X=valid_X,y=valid_y,valid=True)\n                self.valid_performance .update({\"epoch_\" + str(self._epoch): self.performance })\n\n        if valid_X is not None and (self.eval_epoch is None or self.epoch% self.eval_epoch!=0):\n            self.evaluate(X=valid_X, y=valid_y, valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch): self.performance})\n\n\n    def train(self, lb_X=None, lb_y=None, ulb_X=None, lb_idx=None, ulb_idx=None, *args, **kwargs):\n        self.logits = self._network(self.data)\n        lb_logits = self.logits[lb_X]\n        lb_y=self.data.y[lb_X]\n        return lb_logits,lb_y\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits, lb_y=train_result\n        loss=Cross_Entropy(reduction='mean')(lb_logits,lb_y)\n        return loss\n\n\n    def init_estimate_dataloader(self,valid=False):\n        pass\n\n    def init_estimate_dataset(self, X=None, valid=False):\n        if X is not None and not isinstance(X, torch.Tensor):\n            X = torch.BoolTensor(X).to(self.device)\n        if valid:\n            self.pred_mask = X if X is not None else self.data.val_mask\n        else:\n            self.pred_mask = X if X is not None else self.data.test_mask\n\n    def predict_batch_loop(self):\n        with torch.no_grad():\n            self.y_est=self.logits[self.pred_mask]\n\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n    @torch.no_grad()\n    def evaluate(self,X=None,y=None,valid=False):\n        y_pred=self.predict(X,valid=valid)\n        y_score=self.y_score\n        y =self.data.y[X].cpu().detach().numpy() if y is None else y\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance =[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,y_pred,y_score)\n                if self.verbose:\n                    print(score,file=self.file)\n                performance .append(score)\n            self.performance =performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance ={}\n            for key,val in self.evaluation.items():\n                performance [key]=val.scoring(y,y_pred,y_score)\n                if self.verbose:\n                    print(key,' ',performance [key],file=self.file)\n            self.performance  = performance\n            return performance\n        else:\n            performance =self.evaluation.scoring(y,y_pred,y_score)\n            if self.verbose:\n                print(performance ,file=self.file)\n            self.performance  = performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/ICT.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nfrom LAMDA_SSL.utils import Bn_Controller\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nimport torch.nn as nn\nimport torch\nfrom LAMDA_SSL.Augmentation.Vision.Mixup import Mixup\nimport LAMDA_SSL.Config.ICT as config\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\n\nclass ICT(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 lambda_u=config.lambda_u,\n                 alpha=config.alpha,\n                 warmup=config.warmup,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose):\n        # >> Parameter:\n        # >> - warmup: Warm up ratio for unsupervised loss.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - alpha: the parameter of Beta distribution in Mixup.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.alpha=alpha\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def start_fit(self):\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_x = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_x_1 = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\n        lb_logits = self._network(lb_x)\n        index = torch.randperm(ulb_x_1.size(0)).to(self.device)\n        ulb_x_2=ulb_x_1[index]\n        mixup=Mixup(self.alpha)\n        if self.ema is not None:\n            self.ema.apply_shadow()\n        with torch.no_grad():\n            ulb_logits_1 = self._network(ulb_x_1)\n        if self.ema is not None:\n            self.ema.restore()\n        ulb_logits_2=ulb_logits_1[index]\n        mixed_x= mixup.fit(ulb_x_1).transform(ulb_x_2)\n        lam=mixup.lam\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits_mix = self._network(mixed_x)\n        self.bn_controller.unfreeze_bn(self._network)\n        return lb_logits,lb_y,ulb_logits_1,ulb_logits_2,ulb_logits_mix,lam\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits_1,ulb_logits_2,ulb_logits_mix,lam=train_result\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)  # CE_loss for labeled data\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup *Cross_Entropy(use_hard_labels=False, reduction='mean')(ulb_logits_mix,lam * nn.Softmax(dim=-1)(ulb_logits_1)+(1-lam)*\n                                                                            nn.Softmax(dim=-1)(ulb_logits_2))\n\n        loss=Semi_Supervised_Loss(lambda_u =self.lambda_u)(sup_loss,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/ImprovedGAN.py",
    "content": "import copy\nimport torch.nn.functional as F\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nimport LAMDA_SSL.Network.ImprovedGAN as ImGAN\nfrom sklearn.base import ClassifierMixin\nimport torch\nfrom torch.autograd import Variable\nfrom LAMDA_SSL.utils import to_device\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\nfrom LAMDA_SSL.utils import EMA\nimport LAMDA_SSL.Config.ImprovedGAN as config\nfrom LAMDA_SSL.utils import class_status\n\nclass ImprovedGAN(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 dim_in=config.dim_in,\n                 num_classes=config.num_classes,\n                 num_labeled=config.num_labeled,\n                 dim_z=config.dim_z,\n                 hidden_G=config.hidden_G,\n                 hidden_D=config.hidden_D,\n                 noise_level=config.noise_level,\n                 activations_G=config.activations_G,\n                 activations_D=config.activations_D,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 epoch=config.epoch,\n                 network=config.network,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 mu=config.mu,\n                 optimizer=config.optimizer,\n                 weight_decay=config.weight_decay,\n                 lambda_u=config.lambda_u,\n                 ema_decay=config.ema_decay,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 evaluation=config.evaluation,\n                 train_sampler=config.train_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose):\n        # >> Parameter:\n        # >> - dim_in: The dimension of a single instance.\n        # >> - num_classes: The number of classes.\n        # >> - dim_z: The dimension of the latent variables used to generate the data.\n        # >> - hidden_G: The hidden layer dimension of the neural network as the generator. If there are multiple hidden layers, it is represented by a list.\n        # >> - hidden_D: The hidden layer dimension of the neural network as the discriminator. If there are multiple hidden layers, it is represented by a list.。\n        # >> - noise_level: The noise level of each layer of the discriminator.\n        # >> - activations_G: The activation function of each layer of the generator.\n        # >> - activations_D: The activation function of each layer of the discriminator.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - num_labeled: The number of labeled samples.\n        DeepModelMixin.__init__(self, train_dataset=train_dataset,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.hidden_G = hidden_G\n        self.hidden_D = hidden_D\n        self.noise_level = noise_level\n        self.activations_G = activations_G\n        self.activations_D = activations_D\n        self.dim_z=dim_z\n        self.dim_in=dim_in\n        self.num_classes=num_classes\n        self.lambda_u=lambda_u\n        self.num_labeled=num_labeled\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def start_fit(self):\n        self.init_epoch()\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self.num_labeled = self.num_labeled if self.num_labeled is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[0]\n        self.dim_in=self.dim_in if self.dim_in is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[1:]\n        if self.network is None:\n            self.network=ImGAN.ImprovedGAN(dim_in = self.dim_in, hidden_G=self.hidden_G,\n                                       hidden_D=self.hidden_D,activations_D=self.activations_D,\n                                       activations_G=self.activations_G,\n                                       noise_level=self.noise_level,\n                                       dim_out = self.num_classes,dim_z=self.dim_z,device=self.device)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def fit_batch_loop(self,valid_X=None,valid_y=None):\n        for (lb_idx, lb_X, lb_y), (ulb_idx, ulb_X, _) in zip(self._labeled_dataloader, self._unlabeled_dataloader):\n            if self.it_epoch >= self.num_it_epoch or self.it_total >= self.num_it_total:\n                break\n\n            self.start_fit_batch()\n\n            lb_idx = to_device(lb_idx,self.device)\n\n            lb_X = to_device(lb_X,self.device)\n            lb_y = to_device(lb_y,self.device)\n            ulb_idx = to_device(ulb_idx,self.device)\n            ulb_X  = to_device(ulb_X,self.device)\n\n            lb_X = lb_X[0] if isinstance(lb_X, (list, tuple)) else lb_X\n            lb_y = lb_y[0] if isinstance(lb_y, (list, tuple)) else lb_y\n            ulb_X = ulb_X[0] if isinstance(ulb_X, (list, tuple)) else ulb_X\n\n            num_unlabeled = ulb_X.shape[0]\n\n            ulb_X_1, ulb_X_2 = ulb_X[:num_unlabeled // 2], ulb_X[num_unlabeled // 2:]\n\n            train_D_result = self.train_D(lb_X, lb_y, ulb_X_1)\n\n            self.end_fit_batch_D(train_D_result)\n\n            train_G_result = self.train_G(ulb_X_2)\n\n            self.end_fit_batch_G(train_G_result)\n\n            self.it_total += 1\n            self.it_epoch += 1\n            if self.verbose:\n                print(self.it_total,file=self.file)\n\n            if valid_X is not None and self.eval_it is not None and self.it_total % self.eval_it == 0:\n                self.evaluate(X=valid_X, y=valid_y,valid=True)\n                self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n\n    def init_optimizer(self):\n        self._optimizer = copy.deepcopy(self.optimizer)\n        if isinstance(self._optimizer,(list,tuple)):\n            self._optimizerG=self._optimizer[0]\n            self._optimizerD = self._optimizer[1]\n        elif isinstance(self._optimizer,dict):\n            self._optimizerG = self._optimizer['Generator'] if 'Generator' in self._optimizer.keys() \\\n                else self._optimizer['Generation']\n            self._optimizerD = self._optimizer['Discriminator'] if 'Discriminator' in self._optimizer.keys() \\\n                else self._optimizer['Discrimination']\n        else:\n            self._optimizerG=self._optimizer\n            self._optimizerD=copy.deepcopy(self._optimizer)\n\n        if isinstance(self._optimizerG,BaseOptimizer):\n            no_decay = ['bias', 'bn']\n            grouped_parameters = [\n                {'params': [p for n, p in self._network.G.named_parameters() if not any(\n                    nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\n                {'params': [p for n, p in self._network.G.named_parameters() if any(\n                    nd in n for nd in no_decay)], 'weight_decay': 0.0}\n            ]\n            self._optimizerG=self._optimizerG.init_optimizer(params=grouped_parameters)\n\n        if isinstance(self._optimizerD,BaseOptimizer):\n            no_decay = ['bias', 'bn']\n            grouped_parameters = [\n                {'params': [p for n, p in self._network.D.named_parameters() if not any(\n                    nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\n                {'params': [p for n, p in self._network.D.named_parameters() if any(\n                    nd in n for nd in no_decay)], 'weight_decay': 0.0}\n            ]\n            self._optimizerD=self._optimizerD.init_optimizer(params=grouped_parameters)\n\n\n    def init_scheduler(self):\n        self._scheduler = copy.deepcopy(self.scheduler)\n        if isinstance(self._scheduler,(list,tuple)):\n            self._schedulerG=self._scheduler[0]\n            self._schedulerD = self._scheduler[1]\n        elif isinstance(self._scheduler,dict):\n            self._schedulerG = self._scheduler['Generator'] if 'Generator' in self._scheduler.keys() \\\n                else self._scheduler['Generation']\n            self._schedulerD = self._scheduler['Discriminator'] if 'Discriminator' in self._scheduler.keys() \\\n                else self._scheduler['Discrimination']\n        else:\n            self._schedulerG=self._scheduler\n            self._schedulerD=copy.deepcopy(self._scheduler)\n\n        if isinstance(self._schedulerG,BaseScheduler):\n            self._schedulerG=self._schedulerG.init_scheduler(optimizer=self._optimizerG)\n        if isinstance(self._schedulerD,BaseScheduler):\n            self._schedulerD=self._schedulerD.init_scheduler(optimizer=self._optimizerD)\n\n    def init_ema(self):\n        if self.ema_decay is not None:\n            if isinstance(self.ema_decay, (list, tuple)):\n                self.ema_decayG = self.ema_decay[0]\n                self.ema_decayD = self.ema_decay[1]\n            elif isinstance(self.ema_decay, dict):\n                self.ema_decayG = self.ema_decay['Generator'] if 'Generator' in self.ema_decay.keys() \\\n                    else self.ema_decay['Generation']\n                self.ema_decayD = self.ema_decay['Discriminator'] if 'Discriminator' in self.ema_decay.keys() \\\n                    else self.ema_decay['Discrimination']\n            else:\n                self.ema_decayG = self.ema_decay\n                self.ema_decayD = copy.deepcopy(self.ema_decay)\n            self.emaG=EMA(model=self._network.G,decay=self.ema_decayG)\n            self.emaG.register()\n            self.emaD=EMA(model=self._network.D,decay=self.ema_decayD)\n            self.emaD.register()\n        else:\n            self.emaG = None\n            self.emaD = None\n\n    def get_loss_D(self,train_result_D):\n        lb_logits, lb_y, ulb_logits, fake_logits=train_result_D\n        logz_label, logz_unlabel, logz_fake = self.log_sum_exp(lb_logits), \\\n                                              self.log_sum_exp(ulb_logits), \\\n                                              self.log_sum_exp(fake_logits) # log ∑e^x_i\n        prob_label = torch.gather(lb_logits, 1, lb_y.unsqueeze(1).long()) # log e^x_label = x_label\n        sup_loss = -torch.mean(prob_label) + torch.mean(logz_label)\n        unsup_loss = 0.5 * (-torch.mean(logz_unlabel) + torch.mean(F.softplus(logz_unlabel))  + # real_data: log Z/(1+Z)\n                            torch.mean(F.softplus(logz_fake)))\n        loss=sup_loss+self.lambda_u*unsup_loss\n        return loss\n\n    def get_loss_G(self,train_result_G):\n        fake_feature,ulb_feature=train_result_G\n        loss = torch.mean((fake_feature - ulb_feature) ** 2)\n        return loss\n\n    def end_fit_batch_D(self,train_result_D):\n        loss = self.get_loss_D(train_result_D)\n        self.optimize_D(loss)\n\n    def end_fit_batch_G(self,train_result_G):\n        loss = self.get_loss_G(train_result_G)\n        self.optimize_G(loss)\n\n    def optimize_D(self,loss):\n        self._optimizerD.zero_grad()\n        loss.backward()\n        self._optimizerD.step()\n        if self._schedulerD is not None:\n            self._schedulerD.step()\n        if self.emaD is not None:\n            self.emaD.update()\n\n\n    def optimize_G(self,loss):\n        self._optimizerG.zero_grad()\n        self._optimizerD.zero_grad()\n        loss.backward()\n        self._optimizerG.step()\n        if self._schedulerG is not None:\n            self._schedulerG.step()\n        if self.emaG is not None:\n            self.emaG.update()\n\n    def log_sum_exp(self,x, axis=1):\n        m = torch.max(x, dim=1)[0]\n        return m + torch.log(torch.sum(torch.exp(x - m.unsqueeze(1)), dim=axis))\n\n    def train_D(self,lb_X,lb_y,ulb_X):\n        lb_X=lb_X.view(lb_X.shape[0],-1)\n        ulb_X=ulb_X.view(ulb_X.shape[0],-1)\n        lb_logits=self._network.D(lb_X)\n        ulb_logits=self._network.D(ulb_X)\n        fake_X=self._network.G(ulb_X.size()[0]).view(ulb_X.size()).detach()\n        fake_logits =self._network.D(fake_X)\n        return lb_logits, lb_y, ulb_logits, fake_logits\n\n    def train_G(self, ulb_X):\n        ulb_X = ulb_X.view(ulb_X.shape[0], -1)\n        fake_X = self._network.G(ulb_X.size()[0]).view(ulb_X.size())\n        fake_logits = self._network.D(fake_X)\n        fake_feature=self._network.D.feature\n\n        ulb_logits = self._network.D(Variable(ulb_X))\n        ulb_feature=self._network.D.feature\n\n        fake_feature = torch.mean(fake_feature, dim = 0)\n        ulb_feature = torch.mean(ulb_feature, dim = 0)\n\n        return fake_feature,ulb_feature\n\n    @torch.no_grad()\n    def estimate(self, X, idx=None, *args, **kwargs):\n        X=X.view(X.shape[0],-1)\n        outputs = self._network(X)\n        return outputs\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n    def generate(self,num,z=None):\n\n        z = Variable(torch.randn(num, self.dim_z).to(self.device)) if z is None else z\n        z=self._network.G(num,z)\n        # print(z,file=self.file)\n        z=z.view(tuple([z.shape[0]])+tuple(self.dim_in)).detach().numpy()\n        return z\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/LabelPropagation.py",
    "content": "from LAMDA_SSL.Base.TransductiveEstimator import TransductiveEstimator\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nimport sklearn.semi_supervised._label_propagation as sklp\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.LabelPropagation as config\n\nclass LabelPropagation(TransductiveEstimator,ClassifierMixin):\n    def __init__(\n        self,\n        kernel=config.kernel,\n        gamma=config.gamma,\n        n_neighbors=config.n_neighbors,\n        max_iter=config.max_iter,\n        tol=config.tol,\n        n_jobs=config.n_jobs,evaluation=config.evaluation,\n        verbose=config.verbose,file=config.file\n    ):\n        # >> Parameter:\n        # >> - kernel: The kernel function which can be inputted as a string 'rbf' or 'knn' or as a callable function.\n        # >> - gamma: The gamma value when the kernel function is rbf kernel.\n        # >> - n_neighbors: The n value when the kernel function is n_neighbors kernel.\n        # >> - max_iter: The maximum number of iterations.\n        # >> - tol: Convergence tolerance.\n        # >> - n_jobs: The number of parallel jobs.\n        self.max_iter = max_iter\n        self.tol = tol\n        self.kernel = kernel\n        self.gamma = gamma\n        self.n_neighbors = n_neighbors\n\n        self.n_jobs = n_jobs\n\n        self.model=sklp.LabelPropagation(kernel=self.kernel,gamma=self.gamma,n_neighbors=self.n_neighbors,\n                                  max_iter=self.max_iter,tol=self.tol,n_jobs=n_jobs)\n        self.evaluation = evaluation\n        self.verbose=verbose\n        self.file=file\n\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type=ClassifierMixin._estimator_type\n\n    def fit(self,X,y,unlabeled_X=None):\n        U=len(unlabeled_X)\n        _X = np.vstack([X, unlabeled_X])\n        unlabeled_y = np.ones(U)*-1\n        _y = np.hstack([y, unlabeled_y])\n        self.model.fit(_X,_y)\n\n        self.unlabeled_X=unlabeled_X\n        self.unlabeled_y=self.model.transduction_[-U:]\n        self.unlabeled_y_proba=self.model.label_distributions_[-U:]\n        return self\n\n    def predict(self,X=None,Transductive=True):\n        if Transductive:\n            y_pred=self.unlabeled_y\n        else:\n            y_proba= self.predict_proba(X,Transductive=Transductive)\n            y_pred=np.argmax(y_proba, axis=1)\n        return y_pred\n\n    def predict_proba(self,X=None,Transductive=True):\n        if Transductive:\n            y_proba=self.unlabeled_y_proba\n        else:\n            y_proba= self.model.predict_proba(X)\n        return y_proba\n\n\n    def evaluate(self,X=None,y=None,Transductive=True):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X,Transductive=Transductive)\n        self.y_pred=self.predict(X,Transductive=Transductive)\n\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/LabelSpreading.py",
    "content": "from LAMDA_SSL.Base.TransductiveEstimator import TransductiveEstimator\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nimport sklearn.semi_supervised._label_propagation as sklp\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.LabelSpreading as config\n\nclass LabelSpreading(TransductiveEstimator,ClassifierMixin):\n    def __init__(\n        self,\n        kernel=config.kernel,\n        gamma=config.gamma,\n        n_neighbors=config.n_neighbors,\n        alpha=config.alpha,\n        max_iter=config.max_iter,\n        tol=config.tol,\n        n_jobs=config.n_jobs,evaluation=config.evaluation,\n        verbose=config.verbose,file=config.file\n    ):\n        # >> Parameter:\n        # >> - kernel: 'rbf'、'knn' or callable. Specifies the kernel type to be used in the algorithm.\n        # >> - gamma: The gamma value when the kernel function is rbf kernel.\n        # >> - n_neighbors: The n value when the kernel function is n_neighbors kernel.\n        # >> - alpha: The proportion of labels updates in each iteration.\n        # >> - max_iter: The maximum number of iterations.\n        # >> - tol: Convergence tolerance.\n        # >> - n_jobs: The number of parallel jobs.\n        self.max_iter = max_iter\n        self.tol = tol\n        self.kernel = kernel\n        self.gamma = gamma\n        self.n_neighbors = n_neighbors\n        self.alpha=alpha\n        self.n_jobs = n_jobs\n        self.model=sklp.LabelSpreading(kernel=self.kernel,gamma=self.gamma,n_neighbors=self.n_neighbors,\n                                  alpha=self.alpha,max_iter=self.max_iter,tol=self.tol,n_jobs=n_jobs)\n        self.evaluation = evaluation\n        self.verbose=verbose\n        self.file=file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type=ClassifierMixin._estimator_type\n\n    def fit(self,X,y,unlabeled_X=None):\n        U=len(unlabeled_X)\n        _X = np.vstack([X, unlabeled_X])\n        unlabeled_y = np.ones(U)*-1\n        _y = np.hstack([y, unlabeled_y])\n        self.model.fit(_X,_y)\n\n        self.unlabeled_X=unlabeled_X\n        self.unlabeled_y=self.model.transduction_[-U:]\n        self.unlabeled_y_proba=self.model.label_distributions_[-U:]\n        return self\n\n    def predict(self,X=None,Transductive=True):\n        if Transductive:\n            y_pred=self.unlabeled_y\n        else:\n            y_proba= self.predict_proba(X,Transductive=Transductive)\n            y_pred=np.argmax(y_proba, axis=1)\n        return y_pred\n\n    def predict_proba(self,X=None,Transductive=True):\n        if Transductive:\n            y_proba=self.unlabeled_y_proba\n        else:\n            y_proba= self.model.predict_proba(X)\n        return y_proba\n\n\n    def evaluate(self,X=None,y=None,Transductive=True):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X,Transductive=Transductive)\n        self.y_pred=self.predict(X,Transductive=Transductive)\n\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/LadderNetwork.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nimport LAMDA_SSL.Network.LadderNetwork  as Ladder\nfrom torch.autograd import Variable\nfrom sklearn.base import ClassifierMixin\nimport torch\nimport torch.nn as nn\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nimport LAMDA_SSL.Config.LadderNetwork as config\nfrom LAMDA_SSL.utils import class_status\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.MSE import MSE\n\nclass LadderNetwork(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 dim_in=config.dim_in,\n                 num_classes=config.num_classes,\n                 noise_std=config.noise_std,\n                 lambda_u=config.lambda_u,\n                 dim_encoder=config.dim_encoder,\n                 encoder_activations=config.encoder_activations,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 evaluation=config.evaluation,\n                 train_sampler=config.train_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 labeled_batch_sampler=config.train_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose,\n                 ):\n        # >> Parameter:\n        # >> - dim_in: The dimension of a single instance.\n        # >> - num_classes: The number of classes.\n        # >> - noise_std: The noise level of each layer of the discriminator.\n        # >> - lambda_u: The proportion of consistency loss of each layer in LadderNetwork.\n        # >> - encoder_sizes: The dimension of each layer of the encoder.\n        # >> - encoder_activations: The activation function of each layer of the encoder.\n        DeepModelMixin.__init__(self, train_dataset=train_dataset,\n                                labeled_dataset=labeled_dataset,\n                                unlabeled_dataset=unlabeled_dataset,\n                                valid_dataset=valid_dataset,\n                                test_dataset=test_dataset,\n                                train_dataloader=train_dataloader,\n                                labeled_dataloader=labeled_dataloader,\n                                unlabeled_dataloader=unlabeled_dataloader,\n                                valid_dataloader=valid_dataloader,\n                                test_dataloader=test_dataloader,\n                                network=network,\n                                train_sampler=train_sampler,\n                                labeled_sampler=labeled_sampler,\n                                unlabeled_sampler=unlabeled_sampler,\n                                train_batch_sampler=train_batch_sampler,\n                                labeled_batch_sampler=labeled_batch_sampler,\n                                unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                valid_sampler=valid_sampler,\n                                valid_batch_sampler=valid_batch_sampler,\n                                test_sampler=test_sampler,\n                                test_batch_sampler=test_batch_sampler,\n                                epoch=epoch,\n                                num_it_epoch=num_it_epoch,\n                                num_it_total=num_it_total,\n                                eval_epoch=eval_epoch,\n                                eval_it=eval_it,\n                                mu=mu,\n                                weight_decay=weight_decay,\n                                ema_decay=ema_decay,\n                                optimizer=optimizer,\n                                scheduler=scheduler,\n                                device=device,\n                                evaluation=evaluation,\n                                parallel=parallel,\n                                file=file,\n                                verbose=verbose)\n        self.dim_in=dim_in\n        self.num_classes=num_classes\n        self.noise_std = noise_std\n        self.lambda_u = lambda_u\n        self.dim_encoder = dim_encoder\n        self.encoder_activations = encoder_activations\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def start_fit(self):\n        self.init_epoch()\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self.dim_in=self.dim_in if self.dim_in is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[1:]\n        if self.network is None:\n            self.network=Ladder.LadderNetwork(dim_encoder=self.dim_encoder, encoder_activations=self.encoder_activations,\n                      noise_std=self.noise_std,dim_in=self.dim_in,num_classes=self.num_classes,device=self.device)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def init_optimizer(self):\n        self._optimizer = copy.deepcopy(self.optimizer)\n        if isinstance(self._optimizer,BaseOptimizer):\n            self._optimizer=self._optimizer.init_optimizer(params=self._network.parameters())\n\n    def train(self,lb_X=None,lb_y=None,ulb_X=None,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X,(list,tuple)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(list,tuple)) else lb_y\n        ulb_X=ulb_X[0]if isinstance(ulb_X,(list,tuple)) else ulb_X\n        lb_X=lb_X.view(lb_X.shape[0],-1)\n        ulb_X = ulb_X.view(ulb_X.shape[0], -1)\n        lb_X= Variable(lb_X, requires_grad=False)\n        lb_y = Variable(lb_y, requires_grad=False)\n        ulb_X = Variable(ulb_X)\n\n        # do a noisy pass for labelled data\n        lb_noise_logits = nn.Softmax(dim=-1)(self._network.forward_encoders_noise(lb_X))\n\n        # do a noisy pass for unlabelled_data\n        ulb_noise_logits = nn.Softmax(dim=-1)(self._network.forward_encoders_noise(ulb_X))\n        layers_ulb_tilde_z = self._network.get_encoders_tilde_z(reverse=True)\n\n        # do a clean pass for unlabelled data\n        ulb_clean_logits = nn.Softmax(dim=-1)(self._network.forward_encoders_clean(ulb_X))\n        ulb_pre_layers_z= self._network.get_encoders_z_pre(reverse=True)\n        ulb_layers_z = self._network.get_encoders_z(reverse=True)\n\n        ulb_tilde_z_bottom = self._network.get_encoder_tilde_z_bottom()\n\n        # pass through decoders\n        ulb_layers_hat_z= self._network.forward_decoders(layers_ulb_tilde_z,\n                                                          ulb_noise_logits,\n                                                          ulb_tilde_z_bottom)\n\n        ulb_pre_layers_z.append(ulb_X)\n        ulb_layers_z.append(ulb_X)\n\n        # batch normalize using mean, var of z_pre\n        ulb_layers_bn_hat_z = self._network.decoder_bn_hat_z_layers(ulb_layers_hat_z, ulb_pre_layers_z)\n        return lb_noise_logits, lb_y, ulb_layers_z, ulb_layers_bn_hat_z\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_noise_logits, lb_y, ulb_layers_z, ulb_layers_bn_hat_z=train_result\n        sup_loss = Cross_Entropy(reduction='mean')(lb_noise_logits, lb_y)\n        unsup_loss = 0.\n        for lambda_u, z, bn_hat_z in zip(self.lambda_u, ulb_layers_z, ulb_layers_bn_hat_z):\n            c = lambda_u * MSE(reduction='mean')(bn_hat_z, z)\n            unsup_loss += c\n        loss = sup_loss+ unsup_loss\n        return loss\n\n    def optimize(self,loss,*args,**kwargs):\n        self._network.zero_grad()\n        loss.backward()\n        self._optimizer.step()\n\n\n\n    def end_fit_epoch(self):\n        if self._scheduler is not None:\n            self._scheduler.step()\n\n    @torch.no_grad()\n    def estimate(self, X, idx=None, *args, **kwargs):\n        _X=X.view(X.shape[0],-1)\n        outputs = self._network(_X)\n        return outputs\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/LapSVM.py",
    "content": "import numpy as np\nfrom scipy.optimize import minimize\nfrom sklearn.neighbors import kneighbors_graph\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nfrom sklearn.metrics.pairwise import rbf_kernel,linear_kernel\nimport copy\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.LapSVM as config\nfrom scipy import sparse\n\nclass LapSVM(InductiveEstimator,ClassifierMixin):\n    # Binary\n    def __init__(self,\n           distance_function= config.distance_function,\n           gamma_d=config.gamma_d,\n           neighbor_mode =config.neighbor_mode,\n           t=config.t,\n           n_neighbor= config.n_neighbor,\n           kernel_function= config.kernel_function,\n           gamma_k=config.gamma_k,\n           gamma_A= config.gamma_A,\n           gamma_I= config.gamma_I,evaluation=config.evaluation,\n           verbose=config.verbose,file=config.file):\n        # >> Parameter:\n        # >> - distance_function: The distance function for building the graph. This Pamater is valid when neighbor_mode is None.\n        # >> - gamma_d: Kernel parameters related to distance_function.\n        # >> - neighbor_mode: The edge weight after constructing the graph model by k-nearest neighbors. There are two options 'connectivity' and 'distance', 'connectivity' returns a 0-1 matrix, and 'distance' returns a distance matrix.\n        # >> - n_neighbor: k value of k-nearest neighbors.\n        # >> - kernel_function: The kernel function corresponding to SVM.\n        # >> - gamma_k: The gamma parameter corresponding to kernel_function.\n        # >> - gamma_A: Penalty weight for function complexity.\n        # >> - gamma_I: Penalty weight for smoothness of data distribution.\n        self.distance_function=distance_function\n        self.neighbor_mode=neighbor_mode\n        self.n_neighbor=n_neighbor\n        self.t=t\n        self.kernel_function=kernel_function\n        self.gamma_k=gamma_k\n        self.gamma_d=gamma_d\n        self.gamma_A=gamma_A\n        self.gamma_I=gamma_I\n        self.evaluation = evaluation\n        self.verbose=verbose\n        self.file=file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n\n    def fit(self,X,y,unlabeled_X):\n        classes, y_indices = np.unique(y, return_inverse=True)\n        if len(classes)!=2:\n            raise ValueError('LapSVM can only be used in binary classification.')\n\n        self.class_dict={classes[0]:-1,classes[1]:1}\n        self.rev_class_dict = {-1:classes[0] ,  1:classes[1]}\n        y=copy.copy(y)\n        for _ in range(X.shape[0]):\n            y[_]=self.class_dict[y[_]]\n\n        self.X=np.vstack([X,unlabeled_X])\n        Y=np.diag(y)\n        if self.distance_function == 'knn':\n            if self.neighbor_mode=='connectivity':\n                W = kneighbors_graph(self.X, self.n_neighbor, mode='connectivity',include_self=False)\n                W = (((W + W.T) > 0) * 1).todense()\n            else:\n                W = kneighbors_graph(self.X, self.n_neighbor, mode='distance',include_self=False)\n                W = W.maximum(W.T).todense()\n                W = np.exp(-W**2/4/self.t)\n        elif self.distance_function == 'linear':\n            W=linear_kernel(self.X,self.X)\n        elif self.distance_function =='rbf':\n            W=rbf_kernel(self.X,self.X,self.gamma_d)\n\n        elif callable(self.distance_function):\n            if self.gamma_d is not None:\n                W=self.distance_function(self.X,self.X,self.gamma_d)\n            else:\n                W = self.distance_function(self.X, self.X)\n        else:\n            W=rbf_kernel(self.X,self.X,self.gamma_d)\n        L = sparse.csr_matrix(np.diag(np.array(W.sum(0))) - W)\n\n        if self.kernel_function == 'rbf':\n            K = rbf_kernel(self.X,self.X,self.gamma_k)\n        elif self.kernel_function == 'linear':\n            K=linear_kernel(self.X,self.X)\n        elif callable(self.kernel_function):\n            if self.gamma_k is not None:\n                K = self.kernel_function(self.X,self.X,self.gamma_k)\n            else:\n                K = self.kernel_function(self.X, self.X)\n        else:\n            K = rbf_kernel(self.X, self.X, self.gamma_k)\n\n        num_labeled=X.shape[0]\n        num_unlabeled=unlabeled_X.shape[0]\n        J = np.concatenate([np.identity(num_labeled), np.zeros(num_labeled * num_unlabeled).reshape(num_labeled, num_unlabeled)], axis=1)\n        alpha_star = np.linalg.inv(2 * self.gamma_A * np.identity(num_labeled + num_unlabeled) \\\n                                     + ((2 * self.gamma_I) / (num_labeled + num_unlabeled) ** 2) * L.dot(K)).dot(J.T).dot(Y)\n        Q = Y.dot(J).dot(K).dot(alpha_star)\n        Q = (Q+Q.T)/2\n\n        e = np.ones(num_labeled)\n        q = -e\n\n        def objective_fun(x):\n            return (1 / 2) * x.dot(Q).dot(x) + q.dot(x)\n\n        def objective_jac(x):\n            return np.squeeze(np.array(x.T.dot(Q) + q))\n\n        def constraints_fun(x):\n            return x.dot(np.diag(Y))\n\n        def constraints_jac(x):\n            return np.diag(Y)\n\n        bounds = [(0, 1 / num_labeled) for _ in range(num_labeled)]\n\n        constraints = {'type': 'eq', 'fun': constraints_fun, 'jac': constraints_jac}\n\n        beta_star = minimize(objective_fun, np.zeros(num_labeled), jac=objective_jac, constraints=constraints, bounds=bounds)['x']\n        self.alpha = alpha_star.dot(beta_star)\n\n        if self.kernel_function == 'rbf':\n            K = rbf_kernel(self.X,X,self.gamma_k)\n        elif self.kernel_function == 'linear':\n            K= linear_kernel(self.X,X)\n        elif callable(self.kernel_function):\n            if self.gamma_k is not None:\n                K = self.kernel_function(self.X,X,self.gamma_k)\n            else:\n                K = self.kernel_function(self.X,X)\n        else:\n            K = rbf_kernel(self.X, X, self.gamma_k)\n        f = np.squeeze(np.array(self.alpha)).dot(K)\n        idx_super_vectors=np.nonzero((beta_star-1e-8>0)*(1/num_labeled-beta_star>1e-8))[0]\n        try:\n            idx = idx_super_vectors[0]\n        except:\n            idx=0\n        self.bound=np.diag(Y)[idx]-f[idx]\n        return self\n\n\n    def decision_function(self,X):\n        if self.kernel_function == 'rbf':\n            K = rbf_kernel(self.X,X,self.gamma_k)\n        elif self.kernel_function == 'linear':\n            K = linear_kernel(self.X, X)\n        elif callable(self.kernel_function):\n            if self.gamma_k is not None:\n                K = self.kernel_function(self.X,X,self.gamma_k)\n            else:\n                K = self.kernel_function(self.X,X)\n        else:\n            K = rbf_kernel(self.X, X, self.gamma_k)\n        f = np.squeeze(np.array(self.alpha)).dot(K)\n        return f+self.bound\n\n    def predict_proba(self,X):\n        y_desision = self.decision_function(X)\n        y_score = np.full((X.shape[0], 2), 0, np.float)\n        y_score[:,0]=1/(1+np.exp(y_desision))\n        y_score[:, 1] =1- y_score[:,0]\n        return y_score\n\n    def predict(self,X):\n        y_desision = self.decision_function(X)\n        y_pred = np.ones(X.shape[0])\n        y_pred[y_desision < 0] = -1\n        for _ in range(X.shape[0]):\n            y_pred[_]=self.rev_class_dict[y_pred[_]]\n        return y_pred\n\n    def evaluate(self,X,y=None):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X)\n        self.y_pred=self.predict(X)\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/MTCF.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Config.FixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nfrom LAMDA_SSL.utils import class_status\nimport torch.nn as nn\nimport random\nimport torch.nn.functional as F\nimport numpy as np\nimport torch\n\nclass MTCF(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n    \t\t\t alpha=0.75,\n                 lambda_u=75,\n                 T=0.5,\n                 num_classes=None,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n\n        # >> Parameter:\n        # >> - threshold: The confidence threshold for choosing samples.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature.\n        # >> - num_classes: The number of classes for the classification task.\n        # >> - thresh_warmup: Whether to use threshold warm-up mechanism.\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n        # >> - use_DA: Whether to perform distribution alignment for soft labels.\n        # >> - p_target: p(y) based on the labeled examples seen during training.\n\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.lambda_u=lambda_u\n        self.alpha=alpha\n        self.T=T\n        self.weight_decay=weight_decay\n        self.num_classes=num_classes\n        self._estimator_type=ClassifierMixin._estimator_type\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self._network.zero_grad()\n        self._network.train()\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n\n    def interleave_offsets(self, batch, nu):\n        groups = [batch // (nu + 1)] * (nu + 1)\n        for x in range(batch - sum(groups)):\n            groups[-x - 1] += 1\n        offsets = [0]\n        for g in groups:\n            offsets.append(offsets[-1] + g)\n        # assert offsets[-1] == batch\n        return offsets\n\n    def interleave(self, xy, batch):\n        nu = len(xy) - 1\n        offsets = self.interleave_offsets(batch, nu)\n        xy = [[v[offsets[p]:offsets[p + 1]] for p in range(nu + 1)] for v in xy]\n        for i in range(1, nu + 1):\n            xy[0][i], xy[i][i] = xy[i][i], xy[0][i]\n        return [torch.cat(v, dim=0) for v in xy]\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        inputs_u,inputs_u2=ulb_X[0],ulb_X[1]\n        batch_size = lb_X.shape[0]\n        targets_x = torch.zeros(batch_size, self.num_classes).to(self.device).scatter_(1, lb_y.view(-1,1), 1)\n        with torch.no_grad():\n            # compute guessed labels of unlabel samples\n            outputs_u = self._network(inputs_u)\n            outputs_u2 = self._network(inputs_u2)\n            p = (torch.softmax(outputs_u, dim=1) + torch.softmax(outputs_u2, dim=1)) / 2\n            pt = p**(1/self.T)\n            targets_u = pt / pt.sum(dim=1, keepdim=True)\n            targets_u = targets_u.detach()\n\n        # mixup\n        all_inputs = torch.cat([lb_X, inputs_u, inputs_u2], dim=0)\n        all_targets = torch.cat([targets_x, targets_u, targets_u], dim=0)\n\n        l = np.random.beta(self.alpha, self.alpha)\n\n        l = max(l, 1-l)\n\n        idx = torch.randperm(all_inputs.size(0))\n\n        input_a, input_b = all_inputs, all_inputs[idx]\n        target_a, target_b = all_targets, all_targets[idx]\n\n        mixed_input = l * input_a + (1 - l) * input_b\n        mixed_target = l * target_a + (1 - l) * target_b\n\n        # interleave labeled and unlabed samples between batches to get correct batchnorm calculation \n        mixed_input = list(torch.split(mixed_input, batch_size))\n        mixed_input = self.interleave(mixed_input, batch_size)\n\n        logits = [self._network(mixed_input[0])]\n        for input in mixed_input[1:]:\n            logits.append(self._network(input))\n\n        # put interleaved samples back\n        logits = self.interleave(logits, batch_size)\n\n        logits_x = logits[0]\n        logits_u = torch.cat(logits[1:], dim=0)\n        train_result=(logits_x,mixed_target[:batch_size],logits_u,mixed_target[batch_size:])\n        return train_result\n\n\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits, lb_y, w_ulb_logits, s_ulb_logits = train_result\n        w = self._epoch+self.it_epoch/self.num_it_epoch\n        Lx = nn.CrossEntropyLoss()(lb_logits, lb_y)\n        Lu = nn.CrossEntropyLoss()(w_ulb_logits, s_ulb_logits)\n        loss = Lx + w*Lu\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/MeanTeacher.py",
    "content": "from LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.utils import Bn_Controller\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nimport torch\nimport copy\nimport LAMDA_SSL.Config.MeanTeacher as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Consistency import Consistency\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\n\nclass MeanTeacher(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 lambda_u=config.lambda_u,\n                 warmup=config.warmup,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataloader,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - ema_decay: Update weights for the exponential moving average.\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n        # >> - lambda_u: The weight of unsupervised loss.\n        DeepModelMixin.__init__(self, train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_X_1,ulb_X_2=ulb_X[0],ulb_X[1]\n        lb_logits = self._network(lb_X)\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits_2 = self._network(ulb_X_2)\n        self.bn_controller.unfreeze_bn(self._network)\n        if self.ema is not None:\n            self.ema.apply_shadow()\n        with torch.no_grad():\n            ulb_logits_1 = self._network(ulb_X_1)\n        if self.ema is not None:\n            self.ema.restore()\n        return lb_logits,lb_y,ulb_logits_1,ulb_logits_2\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits_1,ulb_logits_2=train_result\n        sup_loss = Cross_Entropy()(lb_logits, lb_y)  # CE_loss for labeled data\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup * Consistency()(ulb_logits_1,ulb_logits_2.detach())  # MSE loss for unlabeled data\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss, unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/MixMatch.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport torch\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Consistency import Consistency\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nimport numpy as np\nfrom LAMDA_SSL.utils import class_status\nfrom LAMDA_SSL.utils import one_hot\nfrom LAMDA_SSL.Augmentation.Vision.Mixup import Mixup\nfrom LAMDA_SSL.utils import Bn_Controller\nimport LAMDA_SSL.Config.MixMatch as config\n\nclass MixMatch(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 num_classes=config.num_classes,\n                 alpha=config.alpha,\n                 warmup=config.warmup,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature for soft labels.\n        # >> - num_classes: The number of classes.\n        # >> - alpha: The parameter of the beta distribution in Mixup.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.T=T\n        self.alpha=alpha\n        self.num_classes=num_classes\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_x_1,ulb_x_2=ulb_X[0],ulb_X[1]\n\n        num_lb = lb_X.shape[0]\n        with torch.no_grad():\n            self.bn_controller.freeze_bn(self._network)\n            ulb_logits_1 = self._network(ulb_x_1)\n            ulb_logits_2 = self._network(ulb_x_2)\n            self.bn_controller.unfreeze_bn(self._network)\n\n            ulb_avg_prob_X = (torch.softmax(ulb_logits_1, dim=1) + torch.softmax(ulb_logits_2, dim=1)) / 2\n            ulb_avg_prob_X = (ulb_avg_prob_X / ulb_avg_prob_X.sum(dim=-1, keepdim=True))\n            # sharpening\n            ulb_sharpen_prob_X = ulb_avg_prob_X ** (1 / self.T)\n            ulb_sharpen_prob_X = (ulb_sharpen_prob_X / ulb_sharpen_prob_X.sum(dim=-1, keepdim=True)).detach()\n            input_labels = torch.cat(\n                [one_hot(lb_y, self.num_classes,device=self.device).to(self.device), ulb_sharpen_prob_X, ulb_sharpen_prob_X], dim=0)\n            inputs = torch.cat([lb_X, ulb_x_1, ulb_x_2])\n            index = torch.randperm(inputs.size(0)).to(self.device)\n\n            mixed_x, mixed_y=Mixup(self.alpha).fit((inputs,input_labels)).transform((inputs[index],input_labels[index]))\n            mixed_x = list(torch.split(mixed_x, num_lb))\n            mixed_x = self.interleave(mixed_x, num_lb)\n\n        _mix_0=self._network(mixed_x[0])\n        logits = [_mix_0]\n        # calculate BN for only the first batch\n        self.bn_controller.freeze_bn(self._network)\n        for ipt in mixed_x[1:]:\n            _mix_i=self._network(ipt)\n            logits.append(_mix_i)\n\n        # put interleaved samples back\n        logits = self.interleave(logits, num_lb)\n        self.bn_controller.unfreeze_bn(self._network)\n        lb_logits = logits[0]\n        ulb_logits = torch.cat(logits[1:], dim=0)\n        return lb_logits,mixed_y[:num_lb],ulb_logits,mixed_y[num_lb:]\n\n    def interleave_offsets(self, batch, num):\n        groups = [batch // (num + 1)] * (num + 1)\n        for x in range(batch - sum(groups)):\n            groups[-x - 1] += 1\n        offsets = [0]\n        for g in groups:\n            offsets.append(offsets[-1] + g)\n        assert offsets[-1] == batch\n        return offsets\n\n    def interleave(self, xy, batch):\n        num = len(xy) - 1\n        offsets = self.interleave_offsets(batch, num)\n        xy = [[v[offsets[p]:offsets[p + 1]] for p in range(num + 1)] for v in xy]\n        for i in range(1, num + 1):\n            xy[0][i], xy[i][i] = xy[i][i], xy[0][i]\n        return [torch.cat(v, dim=0) for v in xy]\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits,ulb_y=train_result\n        sup_loss = Cross_Entropy(use_hard_labels=False,reduction='mean')(lb_logits, lb_y)\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss=_warmup * Consistency(reduction='mean')(torch.softmax(ulb_logits, dim=-1), ulb_y)\n        loss = Semi_Supervised_Loss(self.lambda_u )(sup_loss ,  unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/PiModel.py",
    "content": "from LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Consistency import Consistency\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nfrom LAMDA_SSL.utils import Bn_Controller\nimport copy\nimport numpy as np\nimport LAMDA_SSL.Config.PiModel as config\n\nclass PiModel(DeepModelMixin,InductiveEstimator,ClassifierMixin):\n    def __init__(self,lambda_u=config.lambda_u,\n                 warmup=config.warmup,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4,\n        #              then warmup is performed in the first 40 iterations.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_X_1,ulb_X_2=ulb_X[0],ulb_X[1]\n        lb_logits = self._network(lb_X)\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits_1 = self._network(ulb_X_1)\n        ulb_logits_2 = self._network(ulb_X_2)\n        self.bn_controller.unfreeze_bn(self._network)\n        return lb_logits,lb_y,ulb_logits_1,ulb_logits_2\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits_1,ulb_logits_2=train_result\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup * Consistency(reduction='mean')(ulb_logits_1,ulb_logits_2.detach())\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss ,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/PseudoLabel.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport torch\nimport numpy as np\nimport LAMDA_SSL.Config.PseudoLabel as config\nfrom LAMDA_SSL.utils import Bn_Controller\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\n\nclass PseudoLabel(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 threshold=config.threshold,lambda_u=config.lambda_u,\n                 warmup=config.warmup,mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - threshold: Confidence threshold for selecting samples.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.lambda_u=lambda_u\n        self.threshold=threshold\n        self.warmup=warmup\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        ulb_X = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\n\n        lb_logits = self._network(lb_X)\n\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits = self._network(ulb_X)\n        self.bn_controller.unfreeze_bn(self._network)\n\n        return lb_logits,lb_y,ulb_logits\n\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits=train_result\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)  # CE_loss for labeled data\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        pseudo_label = torch.softmax(ulb_logits, dim=-1)\n        max_probs, max_idx = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold).float()\n        unsup_loss = _warmup*(Cross_Entropy(reduction='none')(ulb_logits, max_idx.detach())*mask).mean() # MSE loss for unlabeled data\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss, unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/ReMixMatch.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport torch\nimport numpy as np\nfrom LAMDA_SSL.utils import class_status\nfrom LAMDA_SSL.utils import one_hot\nfrom LAMDA_SSL.Augmentation.Vision.Mixup import Mixup\nfrom LAMDA_SSL.Augmentation.Vision.Rotate import Rotate\nfrom LAMDA_SSL.utils import Bn_Controller\nimport LAMDA_SSL.Config.ReMixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\n\n\nclass ReMixMatch(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 alpha=config.alpha,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 num_classes=config.num_classes,\n                 warmup=config.warmup,\n                 p_target=config.p_target,\n                 lambda_s=config.lambda_s,\n                 lambda_rot=config.lambda_rot,\n                 rotate_v_list=config.rotate_v_list,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - T: Sharpening temperature for soft labels.\n        # >> - num_classes: The number of classes.\n        # >> - alpha: The parameter of the beta distribution in Mixup.\n        # >> - p_target: The target distribution of labeled data.\n        # >> - lambda_s: The weight for unsupervised loss computed based on pre-mixup data.\n        # >> - lambda_rot: The weight of rotation angle classification loss.\n        # >> - rotate_v_list: A list of rotation angles.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.lambda_s=lambda_s\n        self.lambda_rot=lambda_rot\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.T=T\n        self.alpha=alpha\n        self.num_classes=num_classes\n        self.rotate_v_list=rotate_v_list\n        self.p_model = None\n        self.p_target=p_target\n        self.bn_controller = Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform), dim=0, x=2)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation, dim=1, x=2, y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        if self.p_target is None:\n            class_counts=torch.Tensor(class_status(self._train_dataset.labeled_dataset.y).class_counts).to(self.device)\n            self.p_target = (class_counts / class_counts.sum(dim=-1, keepdim=True))\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n\n        w_ulb_X, s_ulb_X_1, s_ulb_X_2 = ulb_X[0],ulb_X[1],ulb_X[2]\n\n        s_ulb_rot_X_1 = torch.Tensor().to(self.device)\n        rot_index = []\n        for item in s_ulb_X_1:\n            _v = np.random.choice(self.rotate_v_list, 1).item()\n            s_ulb_rot_X_1 = torch.cat((s_ulb_rot_X_1, Rotate(v=_v).fit_transform(item).unsqueeze(0)), dim=0)\n            rot_index.append(self.rotate_v_list.index(_v))\n\n        rot_index = torch.LongTensor(rot_index).to(self.device)\n        num_lb = lb_X.shape[0]\n\n        with torch.no_grad():\n            self.bn_controller.freeze_bn(model=self._network)\n            w_ulb_logits = self._network(w_ulb_X)[0]\n            self.bn_controller.unfreeze_bn(model=self._network)\n            ulb_prob = torch.softmax(w_ulb_logits, dim=1)\n            if self.p_model is None:\n                self.p_model = torch.mean(ulb_prob.detach(), dim=0).to(self.device)\n            else:\n                self.p_model = self.p_model * 0.999 + torch.mean(ulb_prob.detach(), dim=0) * 0.001\n            ulb_prob = ulb_prob * self.p_target / self.p_model\n            ulb_prob = (ulb_prob / ulb_prob.sum(dim=-1, keepdim=True))\n            ulb_sharpen_prob = ulb_prob ** (1 / self.T)\n            ulb_sharpen_prob = (ulb_sharpen_prob / ulb_sharpen_prob.sum(dim=-1, keepdim=True)).detach()\n            mixed_inputs = torch.cat((lb_X, s_ulb_X_1, s_ulb_X_2, w_ulb_X))\n            input_labels = torch.cat(\n                [one_hot(lb_y, self.num_classes,self.device).to(self.device), ulb_sharpen_prob, ulb_sharpen_prob,\n                 ulb_sharpen_prob], dim=0)\n            index = torch.randperm(mixed_inputs.size(0)).to(self.device)\n\n            mixed_X, mixed_y = Mixup(self.alpha).fit((mixed_inputs, input_labels)).transform(\n                (mixed_inputs[index], input_labels[index]))\n            mixed_X = list(torch.split(mixed_X, num_lb))\n            mixed_X = self.interleave(mixed_X, num_lb)\n\n        _mix_0 = self._network(mixed_X[0])[0]\n        logits = [_mix_0]\n        self.bn_controller.freeze_bn(model=self._network)\n        for ipt in mixed_X[1:]:\n            _mix_i = self._network(ipt)[0]\n            logits.append(_mix_i)\n\n        s_ulb_logits_1 = self._network(s_ulb_X_1)[0]\n        rot_logits = self._network(s_ulb_rot_X_1)[1]\n        logits = self.interleave(logits, num_lb)\n        self.bn_controller.unfreeze_bn(model=self._network)\n        lb_logits = logits[0]\n        ulb_logits = torch.cat(logits[1:])\n        return lb_logits,mixed_y[:num_lb],ulb_logits,mixed_y[num_lb:],s_ulb_logits_1,ulb_sharpen_prob,rot_logits,rot_index\n\n    def interleave_offsets(self, batch, num):\n        groups = [batch // (num + 1)] * (num + 1)\n        for x in range(batch - sum(groups)):\n            groups[-x - 1] += 1\n        offsets = [0]\n        for g in groups:\n            offsets.append(offsets[-1] + g)\n        assert offsets[-1] == batch\n        return offsets\n\n    def interleave(self, xy, batch):\n        num = len(xy) - 1\n        offsets = self.interleave_offsets(batch, num)\n        xy = [[v[offsets[p]:offsets[p + 1]] for p in range(num + 1)] for v in xy]\n        for i in range(1, num + 1):\n            xy[0][i], xy[i][i] = xy[i][i], xy[0][i]\n        return [torch.cat(v, dim=0) for v in xy]\n\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,mix_lb_y,ulb_logits,mix_ulb_y,s_ulb_logits_1,ulb_sharpen_prob,rot_logits,rot_index=train_result\n        sup_loss = Cross_Entropy(use_hard_labels=False,reduction='mean')(lb_logits, mix_lb_y)  # CE_loss for labeled data\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss=_warmup *Cross_Entropy(use_hard_labels=False,reduction='mean')(ulb_logits, mix_ulb_y)\n        s_loss=_warmup *Cross_Entropy(use_hard_labels=False,reduction='mean')(s_ulb_logits_1,ulb_sharpen_prob)\n        rot_loss = Cross_Entropy(reduction='mean')(rot_logits,rot_index)\n        loss = sup_loss + self.lambda_u *  unsup_loss+self.lambda_s * s_loss+self.lambda_rot*rot_loss\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/S4L.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport torch\nimport numpy as np\nfrom LAMDA_SSL.utils import class_status\nfrom LAMDA_SSL.Augmentation.Vision.Rotate import Rotate\nfrom LAMDA_SSL.utils import Bn_Controller\nimport LAMDA_SSL.Config.S4L as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\n\n\nclass S4L(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 lambda_u=config.lambda_u,\n                 num_classes=config.num_classes,\n                 p_target=config.p_target,\n                 rotate_v_list=config.rotate_v_list,\n                 labeled_usp=config.labeled_usp,\n                 all_rot=config.all_rot,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - num_classes: The number of classes.\n        # >> - p_target: The target distribution of labeled data.\n        # >> - rotate_v_list: A list of rotation angles.\n        # >> - labeled_usp: Whether to use labeled data when computing the unsupervised loss.\n        # >> - all_rot: Whether to rotate samples by all angles in rotate_v_list.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.num_classes=num_classes\n        self.rotate_v_list=rotate_v_list\n        self.p_model = None\n        self.p_target=p_target\n        self.labeled_usp=labeled_usp\n        self.all_rot=all_rot\n        self.bn_controller = Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        ulb_X = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\n\n        lb_logits = self._network(lb_X)[0]\n\n        rot_X = torch.Tensor().to(self.device)\n        rot_y = []\n\n        for item in ulb_X:\n            if self.all_rot:\n                for _v in self.rotate_v_list:\n                    rot_X = torch.cat((rot_X, Rotate(v=_v).fit_transform(item).unsqueeze(0)), dim=0)\n                    rot_y.append(self.rotate_v_list.index(_v))\n            else:\n                _v = np.random.choice(self.rotate_v_list, 1).item()\n                rot_X = torch.cat((rot_X, Rotate(v=_v).fit_transform(item).unsqueeze(0)), dim=0)\n                rot_y.append(self.rotate_v_list.index(_v))\n        if self.labeled_usp:\n            for item in lb_X:\n                if self.all_rot:\n                    for _v in self.rotate_v_list:\n                        rot_X = torch.cat((rot_X, Rotate(v=_v).fit_transform(item).unsqueeze(0)), dim=0)\n                        rot_y.append(self.rotate_v_list.index(_v))\n                else:\n                    _v = np.random.choice(self.rotate_v_list, 1).item()\n                    rot_X = torch.cat((rot_X, Rotate(v=_v).fit_transform(item).unsqueeze(0)), dim=0)\n                    rot_y.append(self.rotate_v_list.index(_v))\n\n        rot_y = torch.LongTensor(rot_y).to(self.device)\n\n        rot_logits = self._network(rot_X)[1]\n\n        return lb_logits,lb_y,rot_logits,rot_y\n\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,rot_logits,rot_y=train_result\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)  # CE_loss for labeled data\n        rot_loss = Cross_Entropy(reduction='mean')(rot_logits, rot_y)\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss,rot_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/SDNE.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom torch.utils.data.dataset import Dataset\nfrom torch_geometric.data.data import Data\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Network.SDNE as SDNENET\nimport scipy.sparse as sparse\nimport torch\nimport LAMDA_SSL.Config.SDNE as config\n\nclass SDNE(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 base_estimator=config.base_estimator,\n                 alpha=config.alpha,\n                 beta=config.beta,\n                 gamma=config.gamma,\n                 xeqs=config.xeqs,\n                 dim_in=config.dim_in,\n                 num_nodes=config.num_nodes,\n                 hidden_layers=config.hidden_layers,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 eval_epoch=config.eval_epoch,\n                 device=config.device,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - xeqs: Whether to use the adjacency matrix as the feature matrix of the node.\n        # >> - dim_in: The dimension of node features. It is valid when xeqs is False.\n        # >> - num_nodes: The number of nodes.\n        # >> - hidden_layers: Encoder hidden layer dimension.\n        # >> - alpha: The weight of Laplacian regularization.\n        # >> - gamma: The weight of L2 regularation.\n        # >> - beta: The weight of the edges in the graph that are not 0 in the loss of consistency between the input and output of the autoencoder.\n        # >> - base_estimator: A supervised learner that classifies using the node features obtained by the encoder.\n        DeepModelMixin.__init__(self,\n                                    epoch=epoch,\n                                    weight_decay=weight_decay,\n                                    network=network,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    eval_epoch=eval_epoch,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.num_nodes=num_nodes\n        self.hidden_layers=hidden_layers\n        self.dim_in=dim_in\n        self.alpha=alpha\n        self.beta=beta\n        self.xeqs=xeqs\n        self.gamma=gamma\n        self.base_estimator=base_estimator\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self,X=None,y=None,unlabeled_X=None,valid_X=None,valid_y=None,\n            edge_index=None,train_mask=None,labeled_mask=None,unlabeled_mask=None,valid_mask=None,test_mask=None):\n        self.init_train_dataset(X,y,unlabeled_X,edge_index,train_mask,labeled_mask,unlabeled_mask,valid_mask,test_mask)\n        self.init_train_dataloader()\n        self.start_fit()\n        self.fit_epoch_loop(valid_X,valid_y)\n        self.end_fit()\n        return self\n\n    def start_fit(self):\n        self.num_features= self.data.x.shape[1] if self.dim_in is None else self.dim_in\n        self.num_nodes=self.data.x.shape[0] if self.num_nodes is None else self.num_nodes\n        if self.network is None:\n            self.network=SDNENET.SDNE(dim_in=self.num_nodes,hidden_layers=self.hidden_layers) if self.xeqs else \\\n                SDNENET.SDNE(dim_in=self.num_features,hidden_layers=self.hidden_layers)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def init_train_dataloader(self):\n        pass\n\n    def init_train_dataset(self, X=None, y=None, unlabeled_X=None,\n                           edge_index=None,train_mask=None,labeled_mask=None,\n                           unlabeled_mask=None,val_mask=None,test_mask=None):\n        self._train_dataset = copy.deepcopy(self.train_dataset)\n        if isinstance(X,Dataset):\n            X=X.data\n        if not isinstance(X,Data):\n            if not isinstance(X, torch.Tensor):\n                X = torch.Tensor(X)\n            if not isinstance(y, torch.Tensor):\n                y = torch.LongTensor(y)\n            if unlabeled_X is not None and not isinstance(unlabeled_X, torch.Tensor):\n                unlabeled_X = torch.Tensor(unlabeled_X)\n            if not isinstance(edge_index, torch.Tensor):\n                edge_index = torch.LongTensor(edge_index)\n            if not isinstance(train_mask, torch.Tensor):\n                train_mask = torch.BoolTensor(train_mask)\n            if not isinstance(labeled_mask, torch.Tensor):\n                labeled_mask = torch.BoolTensor(labeled_mask)\n            if not isinstance(unlabeled_mask, torch.Tensor):\n                unlabeled_mask = torch.BoolTensor(unlabeled_mask)\n            if not isinstance(val_mask, torch.Tensor):\n                val_mask = torch.BoolTensor(val_mask)\n            if not isinstance(val_mask, torch.Tensor):\n                test_mask = torch.BoolTensor(test_mask)\n\n            if unlabeled_X is not None:\n                X = torch.cat((X, unlabeled_X), dim=0)\n                unlabeled_y = torch.ones(unlabeled_X.shape[0]) * -1\n                y = torch.cat((y, unlabeled_y), dim=0)\n\n            X=Data(x=X,y=y,edge_index=edge_index,train_mask=train_mask,labeled_mask=labeled_mask,\n                   unlabeled_mask=unlabeled_mask,val_mask=val_mask,test_mask=test_mask)\n        self.data=X.to(self.device)\n        self.train_mask = self.data.train_mask.to(self.device) if hasattr(self.data, 'train_mask') else None\n        self.labeled_mask = self.data.labeled_mask.to(self.device) if hasattr(self.data,'labeled_mask') else None\n        self.unlabeled_mask = self.data.unlabeled_mask.to(self.device) if hasattr(self.data,'unlabeled_mask') else None\n        self.valid_mask = self.data.val_mask.to(self.device) if hasattr(self.data, 'val_mask') else None\n        self.test_mask = self.data.test_mask.to(self.device) if hasattr(self.data, 'test_mask') else None\n        adjacency_matrix, laplace_matrix = self.create_adjacency_laplace_matrix()\n        self.adjacency_matrix = torch.from_numpy(adjacency_matrix.toarray()).float().to(self.device)\n        self.laplace_matrix = torch.from_numpy(laplace_matrix.toarray()).float().to(self.device)\n\n    def estimator_fit(self):\n        X=self.embedding[self.data.labeled_mask] if hasattr(self.data,'labeled_mask') and  self.data.labeled_mask is not None \\\n            else self.embedding[self.data.train_mask]\n        y=self.data.y[self.labeled_mask] if hasattr(self.data,'labeled_mask') and  self.data.labeled_mask is not None \\\n            else self.data.y[self.data.train_mask]\n\n        X=X.cpu().detach().numpy()\n        y=y.cpu().detach().numpy()\n        self.base_estimator.fit(X,y)\n\n    def create_adjacency_laplace_matrix(self):\n        self.edge_index=self.data.edge_index\n        adjacency_matrix_data = []\n        adjacency_matrix_row_index = []\n        adjacency_matrix_col_index = []\n        self.num_node=self.data.x.shape[0]\n        for _ in range(self.edge_index.shape[1]):\n            adjacency_matrix_data.append(1.0)\n            adjacency_matrix_row_index.append(self.edge_index[0][_])\n            adjacency_matrix_col_index.append(self.edge_index[1][_])\n\n        adjacency_matrix = sparse.csr_matrix((adjacency_matrix_data,\n                                              (adjacency_matrix_row_index, adjacency_matrix_col_index)),\n                                             shape=(self.num_node, self.num_node))\n        # L = D - A\n        # Calculate degrees\n        adjacency_matrix_ = sparse.csr_matrix((adjacency_matrix_data+adjacency_matrix_data,\n                                               (adjacency_matrix_row_index+adjacency_matrix_col_index,\n                                                adjacency_matrix_col_index+adjacency_matrix_row_index)),\n                                              shape=(self.num_node, self.num_node))\n        degree_matrix = sparse.diags(adjacency_matrix_.sum(axis=1).flatten().tolist()[0])\n        laplace_matrix = degree_matrix - adjacency_matrix_\n        return adjacency_matrix, laplace_matrix\n\n    def end_fit_epoch(self, train_result,*args, **kwargs):\n        self.loss = self.get_loss(train_result)\n        self.optimize(self.loss)\n\n    def fit_epoch_loop(self, valid_X=None, valid_y=None):\n        self.valid_performance = {}\n        self.data=self.data.to(self.device)\n        if valid_X is None:\n            valid_X=self.data.val_mask\n        for self._epoch in range(1,self.epoch+1):\n            print(self._epoch,file=self.file)\n            train_performance = self.train(lb_X=self.data.labeled_mask)\n            self.end_fit_epoch(train_performance)\n            if valid_X is not None and self.eval_epoch is not None and self._epoch % self.eval_epoch==0:\n                self.estimator_fit()\n                self.evaluate(X=valid_X,y=valid_y,valid=True)\n                self.valid_performance.update({\"epoch_\" + str(self._epoch): self.performance})\n\n        if valid_X is not None and (self.eval_epoch is None or self.epoch% self.eval_epoch!=0):\n            self.estimator_fit()\n            self.evaluate(X=valid_X, y=valid_y, valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch): self.performance})\n\n    def end_fit(self):\n        self.estimator_fit()\n\n    def train(self, lb_X=None, lb_y=None, ulb_X=None, lb_idx=None, ulb_idx=None, *args, **kwargs):\n        if self.xeqs:\n            X=self.adjacency_matrix\n        else:\n            X=self.data.x\n        Y,X_hat = self._network(X=X)\n        self.embedding=Y\n        return X,X_hat,Y\n\n    def get_loss(self,train_result,*args,**kwargs):\n        X,X_hat,Y=train_result\n\n        if self.xeqs:\n            beta_matrix = torch.ones_like(self.adjacency_matrix)\n            mask = self.adjacency_matrix != 0\n            beta_matrix[mask] = self.beta\n            loss_2nd = torch.mean(torch.sum(torch.pow((X - X_hat) * beta_matrix, 2), dim=1))\n        else:\n            loss_2nd = torch.mean(torch.sum(torch.pow((X - X_hat) , 2), dim=1))\n        L_reg = 0\n        for param in self._network.parameters():\n            L_reg += self.gamma * torch.sum(param * param)\n        loss_1st =  self.alpha * 2 * torch.trace(torch.matmul(torch.matmul(Y.transpose(0,1), self.laplace_matrix), Y))\n        return loss_1st+loss_2nd+L_reg\n\n\n\n    def predict(self,X=None,valid=False):\n        if X is not None and not isinstance(X, torch.Tensor):\n            X = torch.BoolTensor(X).to(self.device)\n        if valid:\n            X = self.embedding[X] if X is not None else self.embedding[self.data.val_mask]\n        else:\n            X = self.embedding[X] if X is not None else self.embedding[self.data.test_mask]\n        if isinstance(X,torch.Tensor):\n            X=X.cpu().detach().numpy()\n        return self.base_estimator.predict(X)\n\n    def predict_proba(self, X=None, valid=False):\n        if X is not None and not isinstance(X, torch.Tensor):\n            X = torch.BoolTensor(X).to(self.device)\n        if valid:\n            X = self.embedding[X] if X is not None else self.embedding[self.data.val_mask]\n        else:\n            X = self.embedding[X] if X is not None else self.embedding[self.data.test_mask]\n        if isinstance(X,torch.Tensor):\n            X=X.cpu().detach().numpy()\n        return self.base_estimator.predict_proba(X)\n\n    @torch.no_grad()\n    def evaluate(self, X, y=None,valid=False):\n        y_pred = self.predict(X,valid=valid)\n        if hasattr(self.base_estimator,'predict_proba'):\n            y_score = self.predict_proba(X,valid=valid)\n        else:\n            y_score=None\n        self.y_score=y_score\n        self.y_pred=y_pred\n        if y is not None:\n            y=y\n        elif valid:\n            y = self.data.y[self.data.val_mask].cpu().detach().numpy()\n        else:\n            y = self.data.y[X].cpu().detach().numpy() if X is not None else self.data.y[self.data.test_mask].cpu().detach().numpy()\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation, (list, tuple)):\n            performance = []\n            for eval in self.evaluation:\n                score=eval.scoring(y, self.y_pred, self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation, dict):\n            performance = {}\n            for key, val in self.evaluation.items():\n                performance[key] = val.scoring(y, self.y_pred, self.y_score)\n                if self.verbose:\n                    print(key, ' ', performance[key],file=self.file)\n            self.performance = performance\n            return performance\n        else:\n            performance = self.evaluation.scoring(y, self.y_pred, self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/SSGMM.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nfrom torch.utils.data.dataset import Dataset\nfrom LAMDA_SSL.utils import class_status\nimport LAMDA_SSL.Config.SSGMM as config\nfrom scipy import stats\nclass SSGMM(InductiveEstimator,ClassifierMixin):\n    def __init__(self,tolerance=config.tolerance, max_iterations=config.max_iterations, num_classes=config.num_classes,\n                 random_state=config.random_state,evaluation=config.evaluation,verbose=config.verbose,file=config.file):\n        # >> Parameter\n        # >> - num_classes: The number of classes.\n        # >> - tolerance: Tolerance for iterative convergence.\n        # >> - max_iterations: The maximum number of iterations.\n\n        self.num_classes=num_classes\n        self.tolerance=tolerance\n        self.max_iterations=max_iterations\n        self.random_state=random_state\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def normfun(self,x, mu, sigma):\n        pdf=stats.multivariate_normal(mu,sigma,allow_singular=True).pdf(x)\n        return pdf\n\n    def fit(self,X,y,unlabeled_X):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(y).num_classes\n        L=len(X)\n        U=len(unlabeled_X)\n        m=L+U\n        labele_set={}\n\n        for _ in range(self.num_classes):\n            labele_set[_]=set()\n        for _ in range(L):\n            labele_set[y[_]].add(_)\n\n        self.gamma=np.empty((U,self.num_classes))\n        self.alpha = np.zeros(self.num_classes)\n        self.mu=np.zeros((self.num_classes,X.shape[1]))\n        self.sigma=np.zeros((self.num_classes,X.shape[1],X.shape[1]))\n        for i in range(self.num_classes):\n            self.alpha[i]=len(labele_set[i])/L\n            _sum_mu=0\n            for j in labele_set[i]:\n                _sum_mu+=X[j]\n            self.mu[i]=_sum_mu/len(labele_set[i])\n            _sum_sigma=0\n            for j in labele_set[i]:\n                _sum_sigma += np.outer(X[j] - self.mu[i], X[j] - self.mu[i])\n            self.sigma[i]=_sum_sigma/len(labele_set[i])\n        for _ in range(self.max_iterations):\n            # E Step\n            pre=copy.copy(self.alpha)\n\n            for j in range(U):\n                _sum=0\n                for i in range(self.num_classes):\n                    _sum+=self.alpha[i]*self.normfun(unlabeled_X[j],self.mu[i],self.sigma[i])\n                for i in range(self.num_classes):\n                    if _sum==0:\n                        self.gamma[j][i]=self.alpha[i]/self.num_classes\n                    else:\n                        self.gamma[j][i]=self.alpha[i]*self.normfun(unlabeled_X[j],self.mu[i],self.sigma[i])/_sum\n            # M step\n            for i in range(self.num_classes):\n                _sum_mu=0\n                _sum_sigma=np.zeros((X.shape[1],X.shape[1]))\n                _norm=0\n                _norm+=len(labele_set[i])\n\n                for j in labele_set[i]:\n                    _sum_mu+=X[j]\n                for j in range(U):\n                    _sum_mu+=self.gamma[j][i]*unlabeled_X[j]\n                    _norm+=self.gamma[j][i]\n\n                self.mu[i]=_sum_mu/_norm\n\n                self.alpha[i]=_norm/m\n\n\n                for j in labele_set[i]:\n                    _sum_sigma+=np.outer(X[j]-self.mu[i],X[j]-self.mu[i])\n\n                for j in range(U):\n                    _sum_sigma += self.gamma[j][i]*np.outer(unlabeled_X[j] - self.mu[i], unlabeled_X[j] - self.mu[i])\n                self.sigma[i]=_sum_sigma/_norm\n\n            isOptimal = True\n            for i in range(self.num_classes):\n                if abs((self.alpha[i] - pre[i])/pre[i])>self.tolerance:\n                    isOptimal=False\n\n            if isOptimal:\n                break\n\n        return self\n\n    def predict_proba(self,X):\n        y_proba=np.empty((len(X),self.num_classes))\n        for i in range(len(X)):\n            _sum=0\n            for j in range(self.num_classes):\n                _sum+=self.normfun(X[i],self.mu[j],self.sigma[j])\n            for j in range(self.num_classes):\n                if _sum ==0:\n                    y_proba[i][j]=1/self.num_classes\n                else:\n                    y_proba[i][j]=self.normfun(X[i],self.mu[j],self.sigma[j])/_sum\n        return y_proba\n\n    def predict(self,X):\n        y_proba=self.predict_proba(X)\n        y_pred=np.argmax(y_proba, axis=1)\n        return y_pred\n\n    def evaluate(self,X,y=None):\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X)\n        self.y_pred=self.predict(X)\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/SSVAE.py",
    "content": "import copy\nimport torch.nn.functional as F\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nimport LAMDA_SSL.Network.SSVAE as VAE\nimport random\nfrom sklearn.base import ClassifierMixin\nimport torch\nfrom LAMDA_SSL.utils import one_hot\nfrom torch.autograd import Variable\nimport LAMDA_SSL.Config.SSVAE as config\nfrom LAMDA_SSL.utils import class_status\n\nclass SSVAE(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 alpha=config.alpha,\n                 num_labeled=config.num_labeled,\n                 dim_in=config.dim_in,\n                 num_classes=config.num_classes,\n                 dim_z=config.dim_z,\n                 dim_hidden_de=config.dim_hidden_de,\n                 dim_hidden_en_y=config.dim_hidden_en_y,\n                 dim_hidden_en_z=config.dim_hidden_en_z,\n                 activations_de=config.activations_de,\n                 activations_en_y=config.activations_en_y,\n                 activations_en_z=config.activations_en_z,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose):\n        # >> Parameter\n        # >> - alpha: The weight of classification loss.\n        # >> - dim_in: The dimension of the input sample.\n        # >> - num_classes: The number of classes.\n        # >> - dim_z: The dimension of the hidden variable z.\n        # >> - dim_hidden_de: The hidden layer dimension of the decoder.\n        # >> - dim_hidden_en_y: The hidden layer dimension of the encoder for y.\n        # >> - dim_hidden_en_z: The hidden layer dimension of the encoder for z.\n        # >> - activations_de: The activation functions of the decoder.\n        # >> - activations_en_y: The activation functions of the encoder for y.\n        # >> - activations_en_z: The activation functions of the encoder for z.\n        # >> - num_labeled: The number of labeled samples.\n        DeepModelMixin.__init__(self, train_dataset=train_dataset,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.dim_z=dim_z\n        self.dim_in=dim_in\n        self.num_classes=num_classes\n        self.alpha=alpha\n        self.dim_hidden_de = dim_hidden_de\n        self.dim_hidden_en_y = dim_hidden_en_y\n        self.dim_hidden_en_z = dim_hidden_en_z\n        self.activations_de = activations_de\n        self.activations_en_y = activations_en_y\n        self.activations_en_z = activations_en_z\n        self.num_labeled=num_labeled\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def start_fit(self):\n        self.init_epoch()\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self.num_labeled = self.num_labeled if self.num_labeled is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[0]\n        self.dim_in=self.dim_in if self.dim_in is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[1:]\n        if self.network is None:\n            self.network=VAE.SSVAE(dim_in=self.dim_in,num_classes=self.num_classes,dim_z=self.dim_z,\n                               dim_hidden_de=self.dim_hidden_de,activations_de=self.activations_de,\n                               dim_hidden_en_y=self.dim_hidden_en_y, activations_en_y=self.activations_en_y,\n                               dim_hidden_en_z=self.dim_hidden_en_z, activations_en_z=self.activations_en_z,\n                               device=self.device)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def loss_components_fn(self,x, y, z, p_y, p_z, p_x_yz, q_z_xy):\n        return - p_x_yz.log_prob(x).sum(1) \\\n               - p_y.log_prob(y) \\\n               - p_z.log_prob(z).sum(1) \\\n               + q_z_xy.log_prob(z).sum(1)\n\n    def train(self,lb_X=None,lb_y=None,ulb_X=None,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X,(list,tuple)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(list,tuple)) else lb_y\n        ulb_X=ulb_X[0]if isinstance(ulb_X,(list,tuple)) else ulb_X\n        lb_X=lb_X.view(lb_X.shape[0],-1).bernoulli()\n        ulb_X = ulb_X.view(ulb_X.shape[0], -1).bernoulli()\n        lb_q_y = self._network.encode_y(lb_X)\n        ulb_q_y = self._network.encode_y(ulb_X)\n\n        lb_y = one_hot(lb_y, self.num_classes,self.device).to(self.device)\n\n        lb_q_z_xy = self._network.encode_z(lb_X, lb_y)\n\n        lb_z = lb_q_z_xy.rsample()\n        lb_p_x_yz = self._network.decode(lb_y, lb_z)\n\n        lb_p_y=self._network.p_y\n        lb_p_z = self._network.p_z\n\n        ulb_q_z_xy_list = []\n        ulb_p_x_yz_list = []\n        ulb_z_list=[]\n        ulb_p_y=self._network.p_y\n        ulb_p_z=self._network.p_z\n\n        for ulb_y in ulb_q_y.enumerate_support():\n            ulb_q_z_xy = self._network.encode_z(ulb_X, ulb_y)\n            ulb_z = ulb_q_z_xy.rsample()\n            ulb_p_x_yz = self._network.decode(ulb_y, ulb_z)\n            ulb_z_list.append(ulb_z)\n            ulb_q_z_xy_list.append(ulb_q_z_xy)\n            ulb_p_x_yz_list.append(ulb_p_x_yz)\n        return lb_X, lb_y, lb_z, lb_p_y, lb_p_z, lb_q_y, lb_p_x_yz, lb_q_z_xy, ulb_X,ulb_z_list,ulb_p_y,ulb_p_z, ulb_q_y,ulb_p_x_yz_list,ulb_q_z_xy_list\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_X, lb_y, lb_z, lb_p_y, lb_p_z, lb_q_y, lb_p_x_yz, lb_q_z_xy, ulb_X,ulb_z_list,ulb_p_y,ulb_p_z, ulb_q_y,ulb_p_x_yz_list,ulb_q_z_xy_list=train_result\n        sup_loss = self.loss_components_fn(lb_X, lb_y, lb_z, lb_p_y, lb_p_z, lb_p_x_yz, lb_q_z_xy)\n        sup_loss=sup_loss.mean(0)\n        probs=F.softmax(lb_q_y.probs,dim=-1)\n        cls_loss=- self.alpha  * lb_q_y.log_prob(lb_y)\n        cls_loss=cls_loss.mean(0)\n\n\n        unsup_loss = - ulb_q_y.entropy()\n        idx=0\n        for ulb_y in ulb_q_y.enumerate_support():\n            L_xy = self.loss_components_fn(ulb_X, ulb_y, ulb_z_list[idx], ulb_p_y, ulb_p_z, ulb_p_x_yz_list[idx], ulb_q_z_xy_list[idx])\n            unsup_loss += ulb_q_y.log_prob(ulb_y).exp() * L_xy\n            idx+=1\n        unsup_loss=unsup_loss.mean(0)\n        loss=sup_loss+unsup_loss+cls_loss\n        return loss\n\n    def optimize(self,loss,*args,**kwargs):\n        self._network.zero_grad()\n        loss.backward()\n        self._optimizer.step()\n\n    @torch.no_grad()\n    def estimate(self, X, idx=None, *args, **kwargs):\n        X=X.view(X.shape[0],-1).bernoulli()\n        outputs = self._network(X)\n        return outputs\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n    def generate(self,num,z=None,x=None,y=None):\n        if y is not None:\n            y = one_hot(y,self.num_classes,self.device).to(self.device)\n        if x is not None and y is None:\n            y=self._network.encode_y(x)\n        if x is not None and y is not None and z is None:\n            z = self._network.encode_z(x,y)\n        z = Variable(torch.randn(num, self.dim_z).to(self.device)) if z is None else z\n        y = one_hot(Variable(torch.LongTensor([random.randrange(self.num_classes) for _ in range(num)]).to(self.device)),nClass=self.num_classes,device=self.device)\n        result=self._network.decode(z,y).probs\n        result = result.view(tuple([result.shape[0]]) + tuple(self.dim_in)).detach().numpy()\n        return result\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/SemiBoost.py",
    "content": "import numpy as np\nfrom sklearn import neighbors\nimport copy\nfrom sklearn.metrics.pairwise import rbf_kernel,linear_kernel\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\n\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.SemiBoost as config\n\nclass SemiBoost(InductiveEstimator,ClassifierMixin):\n    # Binary\n    def __init__(self, base_estimator = config.base_estimator,\n                        n_neighbors=config.n_neighbors, n_jobs = config.n_jobs,\n                        T = config.T,\n                        sample_percent = config.sample_percent,\n                        sigma_percentile = config.sigma_percentile,\n                        similarity_kernel = config.similarity_kernel,gamma=config.gamma,\n                        evaluation=config.evaluation,verbose=config.verbose,file=config.file):\n        # >> Parameter:\n        # >> - base_estimator: The base supervised learner used in the algorithm.\n        # >> - similarity_kernel: 'rbf'、'knn' or callable. Specifies the kernel type to be used in the algorithm.\n        # >> - n_neighbors: It is valid when the kernel function is 'knn', indicating the value of k in the k nearest neighbors.\n        # >> - n_jobs: It is valid when the kernel function is 'knn', indicating the number of parallel jobs.\n        # >> - gamma: It is valid when the kernel function is 'rbf', indicating the gamma value of the rbf kernel.\n        # >> - T: the number of base learners. It is also the number of iterations.\n        # >> - sample_percent: The number of samples sampled at each iteration as a proportion of the remaining unlabeled samples.\n        # >> - sigma_percentile: Scale parameter used in the 'rbf' kernel.\n        self.base_estimator = base_estimator\n        self.n_neighbors=n_neighbors\n        self.n_jobs=n_jobs\n        self.T=T\n        self.sample_percent=sample_percent\n        self.sigma_percentile=sigma_percentile\n        self.similarity_kernel=similarity_kernel\n        self.gamma=gamma\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self, X, y,unlabeled_X):\n        classes, y_indices = np.unique(y, return_inverse=True)\n\n        self.class_dict={classes[0]:-1,classes[1]:1}\n        self.rev_class_dict = {-1:classes[0] ,  1:classes[1]}\n        y=copy.copy(y)\n        for _ in range(X.shape[0]):\n            y[_]=self.class_dict[y[_]]\n\n        num_labeled=X.shape[0]\n        num_unlabeled=unlabeled_X.shape[0]\n\n        idx=np.arange(num_labeled+num_unlabeled)\n        idx_labeled=idx[:num_labeled]\n        idx_unlabeled=idx[num_labeled:]\n\n        X_all=np.concatenate((X,unlabeled_X))\n        y_all=np.concatenate((y,np.zeros(num_unlabeled,dtype=int)))\n\n        if self.similarity_kernel == 'knn':\n            self.S = neighbors.kneighbors_graph(X_all,\n                                                n_neighbors=self.n_neighbors,\n                                                mode='distance',\n                                                include_self=True,\n                                                n_jobs=self.n_jobs)\n            self.S = np.asarray(self.S.todense())\n        elif self.similarity_kernel == 'linear':\n            self.S = linear_kernel(X_all, X_all)\n        elif self.similarity_kernel == 'rbf':\n            self.S=rbf_kernel(X_all,X_all,self.gamma)\n        elif callable(self.similarity_kernel):\n            if self.gamma is not None:\n                self.S = self.similarity_kernel(X_all,X_all,gamma=self.gamma)\n            else:\n                self.S = self.similarity_kernel(X_all,X_all)\n        else:\n            self.S=rbf_kernel(X_all,X_all,self.gamma)\n\n        self.models = []\n        self.weights = []\n        H = np.zeros(num_unlabeled)\n        for t in range(self.T):\n            p = np.dot(self.S[:,idx_labeled], (y_all[idx_labeled]==1))[idx_unlabeled]*np.exp(-2*H)+\\\n                np.dot(self.S[:,idx_unlabeled], np.exp(H))[idx_unlabeled]*np.exp(-H)\n            q = np.dot(self.S[:,idx_labeled], (y_all[idx_labeled]==-1))[idx_unlabeled]*np.exp(2*H)+\\\n                np.dot(self.S[:,idx_unlabeled], np.exp(-H))[idx_unlabeled]*np.exp(H)\n\n            z = np.sign(p-q)\n            confidence = np.abs(p-q)\n            sample_weights = confidence / np.sum(confidence)\n            if np.any(sample_weights != 0):\n                idx_select = np.random.choice(np.arange(len(z)),\n                                              size = int(self.sample_percent*len(idx_unlabeled)),\n                                              p = sample_weights,\n                                              replace = False)\n                idx_sample = idx_unlabeled[idx_select]\n            else:\n                break\n\n            idx_labeled = np.concatenate([idx_labeled,idx_sample])\n            X_t = X_all[idx_labeled,:]\n            y_all[idx_sample]= z[idx_select]\n            y_t = y_all[idx_labeled]\n\n            base_estimator = self.base_estimator\n            base_estimator.fit(X_t, y_t)\n            h = base_estimator.predict(X_all[idx_unlabeled])\n            idx_unlabeled = np.array([i for i in np.arange(len(y_all)) if i not in idx_labeled])\n\n            e = (np.dot(p,h==-1) + np.dot(q,h==1))/(np.sum(np.add(p,q)))\n            a = 0.25*np.log((1-e)/e)\n            if a<0:\n                break\n            self.models.append(base_estimator)\n            self.weights.append(a)\n            H = np.zeros(len(idx_unlabeled))\n            for i in range(len(self.models)):\n                H = np.add(H, self.weights[i]*self.models[i].predict(X_all[idx_unlabeled]))\n\n            if len(idx_unlabeled) == 0:\n                break\n        self.unlabeled_X=unlabeled_X\n        self.unlabeled_y=y_all[num_unlabeled:]\n        return self\n\n    def predict_proba(self, X):\n        y_proba = np.full((X.shape[0], 2), 0, np.float)\n        for i in range(len(self.models)):\n            y_proba = np.add(y_proba, self.weights[i] * self.models[i].predict_proba(X))\n        return y_proba\n\n    def predict(self, X):\n        y_pred = np.zeros(X.shape[0])\n        for i in range(len(self.models)):\n            y_pred = np.add(y_pred, self.weights[i]*self.models[i].predict(X))\n        y_pred = np.array(list(1 if x>0 else -1 for x in y_pred))\n        y_pred = y_pred.astype(int)\n        for _ in range(X.shape[0]):\n            y_pred[_]=self.rev_class_dict[y_pred[_]]\n        return y_pred\n\n    def evaluate(self,X,y=None):\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X)\n        self.y_pred=self.predict(X)\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/SoftMatch.py",
    "content": "import copy\r\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\r\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\r\nfrom sklearn.base import ClassifierMixin\r\nimport LAMDA_SSL.Config.FixMatch as config\r\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\r\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\r\nfrom LAMDA_SSL.utils import class_status\r\nimport torch.nn as nn\r\nimport random\r\nimport torch.nn.functional as F\r\nimport numpy as np\r\nimport torch\r\n\r\nclass SoftMatch(InductiveEstimator,DeepModelMixin,ClassifierMixin):\r\n    def __init__(self,\r\n                 ema_p=0.999,\r\n                 use_DA=False,\r\n                 num_classes=None,\r\n                 threshold=config.threshold,\r\n                 lambda_u=config.lambda_u,\r\n                 T=config.T,\r\n                 mu=config.mu,\r\n                 weight_decay=config.weight_decay,\r\n                 ema_decay=config.ema_decay,\r\n                 epoch=config.epoch,\r\n                 num_it_epoch=config.num_it_epoch,\r\n                 num_it_total=config.num_it_total,\r\n                 eval_epoch=config.eval_epoch,\r\n                 eval_it=config.eval_it,\r\n                 optimizer=config.optimizer,\r\n                 scheduler=config.scheduler,\r\n                 device=config.device,\r\n                 train_dataset=config.train_dataset,\r\n                 labeled_dataset=config.labeled_dataset,\r\n                 unlabeled_dataset=config.unlabeled_dataset,\r\n                 valid_dataset=config.valid_dataset,\r\n                 test_dataset=config.test_dataset,\r\n                 train_dataloader=config.train_dataloader,\r\n                 valid_dataloader=config.valid_dataloader,\r\n                 test_dataloader=config.test_dataloader,\r\n                 augmentation=config.augmentation,\r\n                 network=config.network,\r\n                 train_sampler=config.train_sampler,\r\n                 train_batch_sampler=config.train_batch_sampler,\r\n                 valid_sampler=config.valid_sampler,\r\n                 valid_batch_sampler=config.valid_batch_sampler,\r\n                 test_sampler=config.test_sampler,\r\n                 test_batch_sampler=config.test_batch_sampler,\r\n                 labeled_dataloader=config.labeled_dataloader,\r\n                 unlabeled_dataloader=config.unlabeled_dataloader,\r\n                 labeled_sampler=config.labeled_sampler,\r\n                 unlabeled_sampler=config.unlabeled_sampler,\r\n                 labeled_batch_sampler=config.labeled_batch_sampler,\r\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\r\n                 parallel=config.parallel,\r\n                 evaluation=config.evaluation,\r\n                 file=config.file,\r\n                 verbose=config.verbose\r\n                 ):\r\n\r\n        # >> Parameter:\r\n        # >> - threshold: The confidence threshold for choosing samples.\r\n        # >> - lambda_u: The weight of unsupervised loss.\r\n        # >> - T: Sharpening temperature.\r\n        # >> - num_classes: The number of classes for the classification task.\r\n        # >> - thresh_warmup: Whether to use threshold warm-up mechanism.\r\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\r\n        # >> - use_DA: Whether to perform distribution alignment for soft labels.\r\n        # >> - p_target: p(y) based on the labeled examples seen during training.\r\n\r\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\r\n                                    valid_dataset=valid_dataset,\r\n                                    labeled_dataset=labeled_dataset,\r\n                                    unlabeled_dataset=unlabeled_dataset,\r\n                                    test_dataset=test_dataset,\r\n                                    train_dataloader=train_dataloader,\r\n                                    valid_dataloader=valid_dataloader,\r\n                                    test_dataloader=test_dataloader,\r\n                                    augmentation=augmentation,\r\n                                    network=network,\r\n                                    train_sampler=train_sampler,\r\n                                    train_batch_sampler=train_batch_sampler,\r\n                                    valid_sampler=valid_sampler,\r\n                                    valid_batch_sampler=valid_batch_sampler,\r\n                                    test_sampler=test_sampler,\r\n                                    test_batch_sampler=test_batch_sampler,\r\n                                    labeled_dataloader=labeled_dataloader,\r\n                                    unlabeled_dataloader=unlabeled_dataloader,\r\n                                    labeled_sampler=labeled_sampler,\r\n                                    unlabeled_sampler=unlabeled_sampler,\r\n                                    labeled_batch_sampler=labeled_batch_sampler,\r\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\r\n                                    epoch=epoch,\r\n                                    num_it_epoch=num_it_epoch,\r\n                                    num_it_total=num_it_total,\r\n                                    eval_epoch=eval_epoch,\r\n                                    eval_it=eval_it,\r\n                                    mu=mu,\r\n                                    weight_decay=weight_decay,\r\n                                    ema_decay=ema_decay,\r\n                                    optimizer=optimizer,\r\n                                    scheduler=scheduler,\r\n                                    device=device,\r\n                                    evaluation=evaluation,\r\n                                    parallel=parallel,\r\n                                    file=file,\r\n                                    verbose=verbose\r\n                                    )\r\n        self.num_classes=num_classes\r\n        self.ema_p=ema_p\r\n        self.use_DA=use_DA\r\n        self.lambda_u=lambda_u\r\n        self.threshold=threshold\r\n        self.T=T\r\n        self.weight_decay=weight_decay\r\n        self._estimator_type=ClassifierMixin._estimator_type\r\n    \r\n    @torch.no_grad()\r\n    def update_prob_t(self, lb_probs, ulb_probs):\r\n        ulb_prob_t = ulb_probs.mean(0)\r\n        self.ulb_prob_t = self.ema_p * self.ulb_prob_t + (1 - self.ema_p) * ulb_prob_t\r\n\r\n        lb_prob_t = lb_probs.mean(0)\r\n        self.lb_prob_t = self.ema_p * self.lb_prob_t + (1 - self.ema_p) * lb_prob_t\r\n\r\n        max_probs, max_idx = ulb_probs.max(dim=-1)\r\n        prob_max_mu_t = torch.mean(max_probs)\r\n        prob_max_var_t = torch.var(max_probs, unbiased=True)\r\n        self.prob_max_mu_t = self.ema_p * self.prob_max_mu_t + (1 - self.ema_p) * prob_max_mu_t.item()\r\n        self.prob_max_var_t = self.ema_p * self.prob_max_var_t + (1 - self.ema_p) * prob_max_var_t.item()\r\n    \r\n    @torch.no_grad()\r\n    def calculate_mask(self, probs):\r\n        max_probs, max_idx = probs.max(dim=-1)\r\n        mu = self.prob_max_mu_t\r\n        var = self.prob_max_var_t\r\n        mask = torch.exp(-((torch.clamp(max_probs - mu, max=0.0) ** 2) / (2 * var / 4)))\r\n        return mask.detach(), max_idx.detach()\r\n    \r\n    def init_transform(self):\r\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\r\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\r\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\r\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\r\n\r\n    def start_fit(self):\r\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\r\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\r\n        self.lb_prob_t = torch.ones((self.num_classes)).to(self.device) / self.num_classes\r\n        self.ulb_prob_t = torch.ones((self.num_classes)).to(self.device) / self.num_classes\r\n        self.prob_max_mu_t = 1.0 / self.num_classes\r\n        self.prob_max_var_t = 1.0 \r\n        self._network.zero_grad()\r\n        self._network.train()\r\n\r\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\r\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\r\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\r\n        w_ulb_X,s_ulb_X=ulb_X[0],ulb_X[1]\r\n        batch_size = lb_X.shape[0]\r\n        inputs=torch.cat((lb_X, w_ulb_X, s_ulb_X))\r\n        logits = self._network(inputs)\r\n        lb_logits = logits[:batch_size]\r\n        w_ulb_logits, s_ulb_logits = logits[batch_size:].chunk(2)\r\n        train_result=(lb_logits,lb_y,w_ulb_logits, s_ulb_logits)\r\n        return train_result\r\n\r\n    @torch.no_grad()\r\n    def distribution_alignment(self, probs):\r\n        # da\r\n        probs = probs * self.lb_prob_t / self.ulb_prob_t\r\n        probs = probs / probs.sum(dim=1, keepdim=True)\r\n        return probs.detach()\r\n\r\n    def get_loss(self,train_result,*args,**kwargs):\r\n        lb_logits, lb_y, w_ulb_logits, s_ulb_logits = train_result\r\n        probs_x_lb = torch.softmax(lb_logits.detach(), dim=-1)\r\n        probs_x_ulb_w = torch.softmax(w_ulb_logits.detach(), dim=-1)\r\n        self.update_prob_t(probs_x_lb, probs_x_ulb_w)\r\n        if self.use_DA:\r\n            probs_x_ulb_w = self.distribution_alignment(probs_x_ulb_w)\r\n        sup_loss=Cross_Entropy(reduction='mean')(logits=lb_logits,targets=lb_y)\r\n        \r\n        mask, targets_u= self.calculate_mask(probs_x_ulb_w)\r\n        \r\n        # pseudo_label = torch.softmax(w_ulb_logits.detach() / self.T, dim=-1)\r\n        # max_probs, targets_u = torch.max(pseudo_label, dim=-1)\r\n        # mask = max_probs.ge(self.threshold).float()\r\n        unsup_loss = (Cross_Entropy(reduction='none')(s_ulb_logits, targets_u) * mask).mean()\r\n        loss=Semi_Supervised_Loss(lambda_u =self.lambda_u)(sup_loss,unsup_loss)\r\n        return loss\r\n\r\n    def predict(self,X=None,valid=None):\r\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/Supervised.py",
    "content": "import torch\r\n\r\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\r\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\r\nfrom sklearn.base import ClassifierMixin\r\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\r\nfrom LAMDA_SSL.Loss.Consistency import Consistency\r\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\r\nfrom LAMDA_SSL.utils import Bn_Controller\r\nimport copy\r\nimport numpy as np\r\nimport LAMDA_SSL.Config.PiModel as config\r\n\r\nclass Supervised(DeepModelMixin,InductiveEstimator,ClassifierMixin):\r\n    def __init__(self,lambda_u=config.lambda_u,\r\n                 warmup=config.warmup,\r\n                 mu=config.mu,\r\n                 ema_decay=config.ema_decay,\r\n                 weight_decay=config.weight_decay,\r\n                 epoch=config.epoch,\r\n                 num_it_epoch=config.num_it_epoch,\r\n                 num_it_total=config.num_it_total,\r\n                 eval_epoch=config.eval_epoch,\r\n                 eval_it=config.eval_it,\r\n                 device=config.device,\r\n                 train_dataset=config.train_dataset,\r\n                 labeled_dataset=config.labeled_dataset,\r\n                 unlabeled_dataset=config.unlabeled_dataset,\r\n                 valid_dataset=config.valid_dataset,\r\n                 test_dataset=config.test_dataset,\r\n                 train_dataloader=config.train_dataloader,\r\n                 labeled_dataloader=config.labeled_dataloader,\r\n                 unlabeled_dataloader=config.unlabeled_dataloader,\r\n                 valid_dataloader=config.valid_dataloader,\r\n                 test_dataloader=config.test_dataloader,\r\n                 train_sampler=config.train_sampler,\r\n                 train_batch_sampler=config.train_batch_sampler,\r\n                 valid_sampler=config.valid_sampler,\r\n                 valid_batch_sampler=config.valid_batch_sampler,\r\n                 test_sampler=config.test_sampler,\r\n                 test_batch_sampler=config.test_batch_sampler,\r\n                 labeled_sampler=config.labeled_sampler,\r\n                 unlabeled_sampler=config.unlabeled_sampler,\r\n                 labeled_batch_sampler=config.labeled_batch_sampler,\r\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\r\n                 augmentation=config.augmentation,\r\n                 network=config.network,\r\n                 optimizer=config.optimizer,\r\n                 scheduler=config.scheduler,\r\n                 evaluation=config.evaluation,\r\n                 parallel=config.parallel,\r\n                 file=config.file,\r\n                 verbose=config.verbose\r\n                 ):\r\n        # >> Parameter:\r\n        # >> - lambda_u: The weight of unsupervised loss.\r\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4,\r\n        #              then warmup is performed in the first 40 iterations.\r\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\r\n                                    valid_dataset=valid_dataset,\r\n                                    test_dataset=test_dataset,\r\n                                    train_dataloader=train_dataloader,\r\n                                    valid_dataloader=valid_dataloader,\r\n                                    test_dataloader=test_dataloader,\r\n                                    augmentation=augmentation,\r\n                                    network=network,\r\n                                    train_sampler=train_sampler,\r\n                                    train_batch_sampler=train_batch_sampler,\r\n                                    valid_sampler=valid_sampler,\r\n                                    valid_batch_sampler=valid_batch_sampler,\r\n                                    test_sampler=test_sampler,\r\n                                    test_batch_sampler=test_batch_sampler,\r\n                                    labeled_dataset=labeled_dataset,\r\n                                    unlabeled_dataset=unlabeled_dataset,\r\n                                    labeled_dataloader=labeled_dataloader,\r\n                                    unlabeled_dataloader=unlabeled_dataloader,\r\n                                    labeled_sampler=labeled_sampler,\r\n                                    unlabeled_sampler=unlabeled_sampler,\r\n                                    labeled_batch_sampler=labeled_batch_sampler,\r\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\r\n                                    epoch=epoch,\r\n                                    num_it_epoch=num_it_epoch,\r\n                                    num_it_total=num_it_total,\r\n                                    eval_epoch=eval_epoch,\r\n                                    eval_it=eval_it,\r\n                                    mu=mu,\r\n                                    weight_decay=weight_decay,\r\n                                    ema_decay=ema_decay,\r\n                                    optimizer=optimizer,\r\n                                    scheduler=scheduler,\r\n                                    device=device,\r\n                                    evaluation=evaluation,\r\n                                    parallel=parallel,\r\n                                    file=file,\r\n                                    verbose=verbose\r\n                                    )\r\n        self.ema_decay=ema_decay\r\n        self.lambda_u=lambda_u\r\n        self.weight_decay=weight_decay\r\n        self.warmup=warmup\r\n        self.bn_controller=Bn_Controller()\r\n        self._estimator_type = ClassifierMixin._estimator_type\r\n\r\n    def init_transform(self):\r\n        # return\r\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\r\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\r\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\r\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\r\n\r\n\r\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\r\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\r\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\r\n        #ulb_X_1,ulb_X_2=ulb_X[0],ulb_X[1]\r\n        lb_logits = self._network(lb_X)\r\n        # with torch.no_grad():\r\n        # ulb_logits=self._network(ulb_X_1)\r\n        # self.bn_controller.freeze_bn(self._network)\r\n        # ulb_logits_1 = self._network(ulb_X_1)\r\n        # ulb_logits_2 = self._network(ulb_X_2)\r\n        # self.bn_controller.unfreeze_bn(self._network)\r\n        return lb_logits,lb_y\r\n\r\n    def get_loss(self,train_result,*args,**kwargs):\r\n        lb_logits,lb_y=train_result\r\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)\r\n        # _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\r\n        # unsup_loss = _warmup * Consistency(reduction='mean')(ulb_logits_1,ulb_logits_2.detach())\r\n        # loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss ,unsup_loss)\r\n        loss=sup_loss\r\n        return loss\r\n\r\n    def predict(self,X=None,valid=None):\r\n        return DeepModelMixin.predict(self,X=X,valid=valid)\r\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/TSVM.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.TransductiveEstimator import TransductiveEstimator\nfrom sklearn.base import ClassifierMixin\nfrom sklearn.svm import SVC\nimport numpy as np\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.TSVM as config\n\nclass TSVM(TransductiveEstimator,ClassifierMixin):\n    def __init__(\n            self,\n            Cl=config.Cl,\n            Cu=config.Cu,\n            kernel=config.kernel,\n            degree=config.degree,\n            gamma=config.gamma,\n            coef0=config.coef0,\n            shrinking=config.shrinking,\n            probability=config.probability,\n            tol=config.tol,\n            cache_size=config.cache_size,\n            class_weight=config.class_weight,\n            max_iter=config.max_iter,\n            decision_function_shape=config.decision_function_shape,\n            break_ties=config.break_ties,\n            random_state=config.random_state,evaluation=config.evaluation,\n            verbose=config.verbose,file=config.file\n    ):\n        # >> Parameter:\n        # >> - Cl: The weight of labeled samples.\n        # >> - Cu: The weight of unlabeled samples.\n        # >> - kernel: 'rbf'、'knn' or callable. Specifies the kernel type to be used in the algorithm.\n        # >> - degree: The polynomial order corresponding to the 'poly' kernel.\n        # >> - gamma: The gamma parameter corresponding to the kernel. It is valid when kernel is 'rbf', 'poly' or 'sigmoid'.\n        # >> - coef0: The constant term of the kernel function. It is valid when kernel is 'poly' or 'sigmoid'.\n        # >> - shrinking: Whether to use the shrinking heuristic method.\n        # >> - probability: Weights for rotation angle classification loss.\n        # >> - tol: Tolerance to stop training, default is 1e-3.\n        # >> - cache_size: The cache size of the Kernel function.\n        # >> - class_weight: The weights of different classes.\n        # >> - verbose: Whether to allow redundant output.\n        # >> - max_iter: The maximum number of iterations. -1 for unlimited.\n        # >> - decision_function_shape: {'ovo', 'ovr'}, default='ovr'. Whether to return a one-vs-rest ('ovr') decision function of shape(n_samples, n_classes) as all other classifiers, or the original one-vs-one ('ovo') decision function of libsvm which has shape (n_samples, n_classes * (n_classes - 1) / 2). However, one-vs-one ('ovo') is always used as multi-class strategy. The parameter is ignored for binary classification.\n        # >> - break_ties: Whether to classify by calculating confidence in the event of a tie.\n        # >> - random_state: A random seed for data shuffling.\n        self.Cl = Cl\n        self.Cu = Cu\n        self.kernel = kernel\n        self.degree = degree\n        self.gamma = gamma\n        self.coef0 = coef0\n        self.shrinking = shrinking\n        self.probability = probability\n        self.tol = tol\n        self.cache_size = cache_size\n        self.class_weight = class_weight\n        self.verbose = verbose\n        self.max_iter = max_iter\n        self.decision_function_shape = decision_function_shape\n        self.break_ties = break_ties\n        self.random_state = random_state\n        self.base_estimator=SVC(C=self.Cl,\n                    kernel=self.kernel,\n                    degree = self.degree,\n                    gamma = self.gamma,\n                    coef0 = self.coef0,\n                    shrinking = self.shrinking,\n                    probability = self.probability,\n                    tol = self.tol,\n                    cache_size = self.cache_size,\n                    class_weight = self.class_weight,\n                    verbose = self.verbose,\n                    max_iter = self.max_iter,\n                    decision_function_shape = self.decision_function_shape,\n                    break_ties = self.break_ties,\n                    random_state = self.random_state)\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.class_dict=None\n        self.rev_class_dict=None\n        self.unlabeled_y_d=None\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self,X,y,unlabeled_X):\n        L=len(X)\n        N = len(X) + len(unlabeled_X)\n        sample_weight = np.ones(N)\n        sample_weight[len(X):] = 1.0*self.Cu/self.Cl\n        classes, y_indices = np.unique(y, return_inverse=True)\n        if len(classes)!=2:\n            raise ValueError('TSVM can only be used in binary classification.')\n\n        self.class_dict={classes[0]:-1,classes[1]:1}\n        self.rev_class_dict = {-1:classes[0] ,  1:classes[1]}\n        y=copy.copy(y)\n        for _ in range(L):\n            y[_]=self.class_dict[y[_]]\n\n        self.base_estimator.fit(X, y)\n\n        unlabeled_y = self.base_estimator.predict(unlabeled_X)\n\n        u_X_id = np.arange(len(unlabeled_y))\n        _X = np.vstack([X, unlabeled_X])\n        _y = np.hstack([y, unlabeled_y])\n\n\n        while self.Cu < self.Cl:\n            self.base_estimator.fit(_X, _y, sample_weight=sample_weight)\n            while True:\n                unlabeled_y_d = self.base_estimator.decision_function(unlabeled_X)\n                self.unlabeled_y_d=unlabeled_y_d\n                epsilon = 1 - unlabeled_y * unlabeled_y_d\n\n                positive_set, positive_id = epsilon[unlabeled_y > 0], u_X_id[unlabeled_y > 0]\n                negative_set, negative_id = epsilon[unlabeled_y < 0], u_X_id[unlabeled_y < 0]\n                positive_max_id = positive_id[np.argmax(positive_set)]\n                negative_max_id = negative_id[np.argmax(negative_set)]\n                a, b = epsilon[positive_max_id], epsilon[negative_max_id]\n                if a > 0 and b > 0 and a + b > 2.0:\n                    unlabeled_y[positive_max_id] = unlabeled_y[positive_max_id] * -1\n                    unlabeled_y[negative_max_id] = unlabeled_y[negative_max_id] * -1\n                    _y = np.hstack([y, unlabeled_y])\n                    self.base_estimator.fit(_X, _y, sample_weight=sample_weight)\n                else:\n                    break\n            self.Cu = min(2*self.Cu, self.Cl)\n            sample_weight[len(X):] = 1.0*self.Cu/self.Cl\n        self.unlabeled_X = unlabeled_X\n        self.unlabeled_y = unlabeled_y\n        return self\n\n    def predict_proba(self, X=None, Transductive=True):\n        if Transductive:\n            y_proba = np.full((self.unlabeled_y_d.shape[0], 2), 0, np.float)\n            y_proba[:, 0] = 1 / (1 + np.exp(self.unlabeled_y_d))\n            y_proba[:, 1] = 1 - y_proba[:, 0]\n        else:\n            y_proba= self.base_estimator.predict_proba(X)\n        return y_proba\n\n    def predict(self,X=None,Transductive=True):\n        if Transductive:\n            result=self.unlabeled_y\n        else:\n            result= self.base_estimator.predict(X)\n        _len=len(result)\n        result=copy.copy(result)\n        for _ in range(_len):\n            result[_]=self.rev_class_dict[result[_]]\n        return result\n\n    def score(self,X=None, y=None,sample_weight=None,Transductive=True):\n        if Transductive:\n            return self.base_estimator.score(self.unlabeled_X,self.unlabeled_y,sample_weight)\n        else:\n            _len=len(X)\n            y=copy.copy(y)\n            for _ in range(_len):\n                y[_] = self.class_dict[y[_]]\n            return self.base_estimator.score(X, y,sample_weight)\n\n    def evaluate(self,X=None,y=None,Transductive=True):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X,Transductive=Transductive)\n        self.y_pred=self.predict(X,Transductive=Transductive)\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/TemporalEnsembling.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport torch\nfrom LAMDA_SSL.utils import class_status\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Consistency import Consistency\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nfrom LAMDA_SSL.utils import Bn_Controller\nimport numpy as np\nimport LAMDA_SSL.Config.TemporalEnsembling as config\n\nclass TemporalEnsembling(InductiveEstimator,DeepModelMixin):\n    def __init__(self,\n                 lambda_u=config.lambda_u,\n                 ema_weight=config.ema_weight,\n                 warmup=config.warmup,\n                 num_classes=config.num_classes,\n                 num_samples = config.num_samples,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n        # >> - ema_weight: Update weight for exponential moving average pseudo labels。\n        # >> - num_classes: The number of classes.\n        # >> - num_samples: The number of samples.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_weight=ema_weight\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.num_classes=num_classes\n        self.num_samples=num_samples\n        self.ema_pslab=None\n        self.epoch_pslab=None\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def start_fit(self):\n        self.init_epoch()\n        num_classes = self.num_classes if self.num_classes is not None else \\\n                        class_status(self._train_dataset.labeled_dataset.y).num_classes\n\n        num_samples = self.num_samples if self.num_samples is not None else \\\n                        self._train_dataset.unlabeled_dataset.__len__()\n        self.epoch_pslab = self.create_soft_pslab(num_samples=num_samples,\n                                           num_classes=num_classes,dtype='rand')\n        self.ema_pslab   = self.create_soft_pslab(num_samples=num_samples,\n                                           num_classes=num_classes,dtype='zero')\n        self.it_total = 0\n        self._network.zero_grad()\n        self._network.train()\n\n    def end_fit_epoch(self):\n        self.update_ema_predictions()\n        if self._scheduler is not None:\n                self._scheduler.step()\n\n    def create_soft_pslab(self, num_samples, num_classes, dtype='rand'):\n        if dtype == 'rand':\n            pslab = torch.randint(0, num_classes, (num_samples, num_classes)).float()\n        elif dtype == 'zero':\n            pslab = torch.zeros(num_samples, num_classes)\n        else:\n            raise ValueError('Unknown pslab dtype: {}'.format(dtype))\n        return pslab.to(self.device)\n\n    def update_ema_predictions(self):\n        self.ema_pslab = (self.ema_weight * self.ema_pslab) + (1.0 - self.ema_weight) * self.epoch_pslab\n        self.epoch_pslab = self.ema_pslab / (1.0 - self.ema_weight ** (self._epoch + 1.0))\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_X = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\n        lb_logits = self._network(lb_X)\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits = self._network(ulb_X)\n        self.bn_controller.unfreeze_bn(self._network)\n        iter_unlab_pslab = self.epoch_pslab[ulb_idx]\n        with torch.no_grad():\n            self.epoch_pslab[ulb_idx] = ulb_logits.clone().detach()\n\n        return lb_logits,lb_y,ulb_logits,iter_unlab_pslab\n\n    def optimize(self,loss,*args,**kwargs):\n        self._network.zero_grad()\n        loss.backward()\n        self._optimizer.step()\n        if self.ema is not None:\n            self.ema.update()\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits,iter_unlab_pslab  = train_result\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup *Consistency(reduction='mean')(ulb_logits,iter_unlab_pslab)\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss, unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/Tri_Training.py",
    "content": "import copy\nimport numpy as np\nimport sklearn\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nfrom torch.utils.data.dataset import Dataset\nimport  LAMDA_SSL.Config.Tri_Training as config\n\nclass Tri_Training(InductiveEstimator,ClassifierMixin):\n    def __init__(self, base_estimator=config.base_estimator,base_estimator_2=config.base_estimator_2,\n                 base_estimator_3=config.base_estimator_3,evaluation=config.evaluation,\n                 verbose=config.verbose,file=config.file):\n        # >> Parameter:\n        # >> - base_estimator: The first base learner in TriTraining.\n        # >> - base_estimator_2: The second base learner in TriTraining.\n        # >> - base_estimator_3: The third base learner in TriTraining.\n        if isinstance(base_estimator,(list,tuple)):\n            self.estimators=base_estimator\n        else:\n            self.estimators=[base_estimator,base_estimator_2,base_estimator_3]\n        if self.estimators[1] is None:\n            self.estimators[1]=copy.deepcopy(self.estimators[0])\n        if self.estimators[2] is None:\n            self.estimators[2] = copy.deepcopy(self.estimators[0])\n        self.evaluation = evaluation\n        self.verbose=verbose\n        self.file=file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def fit(self, X, y, unlabeled_X):\n        for i in range(3):\n            sample = sklearn.utils.resample(X, y)\n            self.estimators[i].fit(*sample)\n        e_prime = [0.5] * 3\n        l_prime = [0] * 3\n        e = [0] * 3\n        update = [False] * 3\n        lb_X, lb_y = [[]] * 3, [[]] * 3\n        improve = True\n        self.iter = 0\n        while improve:\n            self.iter += 1\n            for i in range(3):\n                j, k = np.delete(np.array([0, 1, 2]), i)\n                update[i] = False\n                e[i] = self.measure_error(X, y, j, k)\n                if e[i] < e_prime[i]:\n                    ulb_y_j = self.estimators[j].predict(unlabeled_X)\n                    ulb_y_k = self.estimators[k].predict(unlabeled_X)\n                    lb_X[i] = unlabeled_X[ulb_y_j == ulb_y_k]\n                    lb_y[i] = ulb_y_j[ulb_y_j == ulb_y_k]\n                    if l_prime[i] == 0:\n                        l_prime[i] = int(e[i] / (e_prime[i] - e[i]) + 1)\n                    if l_prime[i] < len(lb_y[i]):\n                        if e[i] * len(lb_y[i]) < e_prime[i] * l_prime[i]:\n                            update[i] = True\n                        elif l_prime[i] > e[i] / (e_prime[i] - e[i]):\n                            lb_index = np.random.choice(len(lb_y[i]), int(e_prime[i] * l_prime[i] / e[i] - 1))\n                            lb_X[i], lb_y[i] = lb_X[i][lb_index], lb_y[i][lb_index]\n                            update[i] = True\n            for i in range(3):\n                if update[i]:\n                    self.estimators[i].fit(np.append(X, lb_X[i], axis=0), np.append(y, lb_y[i], axis=0))\n                    e_prime[i] = e[i]\n                    l_prime[i] = len(lb_y[i])\n            if update == [False] * 3:\n                improve = False\n        return self\n\n    def predict_proba(self,X):\n        y_proba = np.full((X.shape[0], 2), 0, np.float)\n        for i in range(3):\n            y_proba+=self.estimators[i].predict_proba(X)\n        return y_proba\n\n    def predict(self, X):\n        pred = np.asarray([self.estimators[i].predict(X) for i in range(3)])\n        pred[0][pred[1] == pred[2]] = pred[1][pred[1] == pred[2]]\n        y_pred=pred[0]\n        return y_pred\n\n\n\n    def measure_error(self, X, y, j, k):\n        j_pred = self.estimators[j].predict(X)\n        k_pred = self.estimators[k].predict(X)\n        wrong_index = np.logical_and(j_pred != y, k_pred == j_pred)\n        return sum(wrong_index) / sum(j_pred == k_pred)\n\n    def evaluate(self,X,y=None):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_score = self.predict_proba(X)\n        self.y_pred=self.predict(X)\n\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/UASD.py",
    "content": "from LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\r\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\r\nfrom TwoAdaption.Deep.Config.Default_Config import config\r\nfrom LAMDA_SSL.utils import Bn_Controller\r\nfrom sklearn.base import ClassifierMixin\r\nfrom LAMDA_SSL.utils import to_device\r\nimport numpy as np\r\nimport torch\r\nfrom torch.nn import CrossEntropyLoss\r\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\r\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\r\nfrom LAMDA_SSL.utils import class_status\r\n\r\nclass UASD(InductiveEstimator,DeepModelMixin):\r\n    def __init__(self,\r\n                 lambda_u=1.0,\r\n                 ema_weight=None,\r\n                 warmup=None,\r\n                 num_classes=None,\r\n                 num_samples = None,\r\n                 mu=1.0,\r\n                 ema_decay=None,\r\n                 threshold=0.95,\r\n                 weight_decay=None,\r\n                 epoch=1,\r\n                 num_it_epoch=2000,\r\n                 num_it_total=None,\r\n                 eval_epoch=None,\r\n                 eval_it=None,\r\n                 device='cuda:0',\r\n                 train_dataset=config.train_dataset,\r\n                 labeled_dataset=config.labeled_dataset,\r\n                 unlabeled_dataset=config.unlabeled_dataset,\r\n                 valid_dataset=config.valid_dataset,\r\n                 test_dataset=config.test_dataset,\r\n                 train_dataloader=config.train_dataloader,\r\n                 labeled_dataloader=config.labeled_dataloader,\r\n                 unlabeled_dataloader=config.unlabeled_dataloader,\r\n                 valid_dataloader=config.valid_dataloader,\r\n                 test_dataloader=config.test_dataloader,\r\n                 train_sampler=config.train_sampler,\r\n                 train_batch_sampler=config.train_batch_sampler,\r\n                 valid_sampler=config.valid_sampler,\r\n                 valid_batch_sampler=config.valid_batch_sampler,\r\n                 test_sampler=config.test_sampler,\r\n                 test_batch_sampler=config.test_batch_sampler,\r\n                 labeled_sampler=config.labeled_sampler,\r\n                 unlabeled_sampler=config.unlabeled_sampler,\r\n                 labeled_batch_sampler=config.labeled_batch_sampler,\r\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\r\n                 augmentation=config.augmentation,\r\n                 network=config.network,\r\n                 optimizer=config.optimizer,\r\n                 scheduler=config.scheduler,\r\n                 evaluation=config.evaluation,\r\n                 parallel=config.parallel,\r\n                 file=config.file,\r\n                 verbose=config.verbose\r\n                 ):\r\n        # >> Parameter\r\n        # >> - lambda_u: The weight of unsupervised loss.\r\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\r\n        # >> - ema_weight: Update weight for exponential moving average pseudo labels。\r\n        # >> - num_classes: The number of classes.\r\n        # >> - num_samples: The number of samples.\r\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\r\n                                    valid_dataset=valid_dataset,\r\n                                    test_dataset=test_dataset,\r\n                                    train_dataloader=train_dataloader,\r\n                                    valid_dataloader=valid_dataloader,\r\n                                    test_dataloader=test_dataloader,\r\n                                    augmentation=augmentation,\r\n                                    network=network,\r\n                                    train_sampler=train_sampler,\r\n                                    train_batch_sampler=train_batch_sampler,\r\n                                    valid_sampler=valid_sampler,\r\n                                    valid_batch_sampler=valid_batch_sampler,\r\n                                    test_sampler=test_sampler,\r\n                                    test_batch_sampler=test_batch_sampler,\r\n                                    labeled_dataset=labeled_dataset,\r\n                                    unlabeled_dataset=unlabeled_dataset,\r\n                                    labeled_dataloader=labeled_dataloader,\r\n                                    unlabeled_dataloader=unlabeled_dataloader,\r\n                                    labeled_sampler=labeled_sampler,\r\n                                    unlabeled_sampler=unlabeled_sampler,\r\n                                    labeled_batch_sampler=labeled_batch_sampler,\r\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\r\n                                    epoch=epoch,\r\n                                    num_it_epoch=num_it_epoch,\r\n                                    num_it_total=num_it_total,\r\n                                    eval_epoch=eval_epoch,\r\n                                    eval_it=eval_it,\r\n                                    mu=mu,\r\n                                    weight_decay=weight_decay,\r\n                                    ema_decay=ema_decay,\r\n                                    optimizer=optimizer,\r\n                                    scheduler=scheduler,\r\n                                    device=device,\r\n                                    evaluation=evaluation,\r\n                                    parallel=parallel,\r\n                                    file=file,\r\n                                    verbose=verbose\r\n                                    )\r\n        self.ema_weight=ema_weight\r\n        self.lambda_u=lambda_u\r\n        self.weight_decay=weight_decay\r\n        self.warmup=warmup\r\n        self.threshold=threshold\r\n        self.num_classes=num_classes\r\n        self.num_samples=num_samples\r\n        self.ema_pslab=None\r\n        self.epoch_pslab=None\r\n        self.bn_controller=Bn_Controller()\r\n        self._estimator_type = ClassifierMixin._estimator_type\r\n\r\n    def start_fit(self):\r\n        self.init_epoch()\r\n        num_classes = self.num_classes if self.num_classes is not None else \\\r\n                        class_status(self._train_dataset.labeled_dataset.y).num_classes\r\n        print(num_classes)\r\n        num_samples = self.num_samples if self.num_samples is not None else \\\r\n                        self._train_dataset.unlabeled_dataset.__len__()\r\n        self.epoch_pslab = torch.zeros(num_samples, num_classes).to(self.device)\r\n        self.pslab   = torch.zeros(num_samples, num_classes).to(self.device)\r\n        self.it_total = 0\r\n        self._network.zero_grad()\r\n        self._network.train()\r\n\r\n    def end_fit_epoch(self):\r\n        self.update_predictions()\r\n\r\n    def update_predictions(self):\r\n        self.pslab = ((self._epoch-1)*self.pslab + self.epoch_pslab)/self._epoch\r\n\r\n\r\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\r\n\r\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\r\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\r\n        ulb_X = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\r\n        lb_logits = self._network(lb_X)\r\n        self.bn_controller.freeze_bn(self._network)\r\n        ulb_logits = self._network(ulb_X)\r\n        self.bn_controller.unfreeze_bn(self._network)\r\n        iter_unlab_pslab = self.pslab[ulb_idx]\r\n        with torch.no_grad():\r\n            self.epoch_pslab[ulb_idx] = ulb_logits.softmax(1).clone().detach()\r\n\r\n        return lb_logits,lb_y,ulb_logits,iter_unlab_pslab\r\n\r\n\r\n    def get_loss(self,train_result,*args,**kwargs):\r\n        lb_logits,lb_y,ulb_logits,iter_unlab_pslab  = train_result\r\n        sup_loss = CrossEntropyLoss(reduction='mean')(lb_logits, lb_y)\r\n        iter_unlab_pslab=(iter_unlab_pslab*(self._epoch-1)+ulb_logits.softmax(1))/self._epoch\r\n        max_probs, targets_u = torch.max(iter_unlab_pslab, dim=-1)\r\n        mask = max_probs.ge(self.threshold).float()\r\n        unsup_loss = (CrossEntropyLoss(reduction='none')(ulb_logits, iter_unlab_pslab.detach()) * mask).mean()\r\n        loss=sup_loss+self.lambda_u*(self._epoch/self.epoch)*unsup_loss\r\n        return loss\r\n\r\n    def predict(self,X=None,valid=None):\r\n        return DeepModelMixin.predict(self,X=X,valid=valid)"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/UDA.py",
    "content": "import copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport torch\nfrom LAMDA_SSL.utils import class_status\nimport math\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nimport LAMDA_SSL.Config.UDA as config\n\nclass UDA(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 num_classes=config.num_classes,\n                 tsa_schedule=config.tsa_schedule,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - threshold: The confidence threshold for choosing samples.\n        # >> - num_classes: The number of classes.\n        # >> - tsa_schedule: Threshold adjustment strategy, optional 'linear', 'exp' or 'log'.\n        # >> - T: Sharpening temperature for soft labels.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.threshold=threshold\n        self.tsa_schedule=tsa_schedule\n        self.num_classes=num_classes\n        self.T=T\n        self.weight_decay=weight_decay\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n\n    def start_fit(self):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(self._train_dataset.labeled_dataset.y).num_classes\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        w_ulb_X,s_ulb_X=ulb_X[0],ulb_X[1]\n        num_lb = lb_X.shape[0]\n        inputs = torch.cat([lb_X, w_ulb_X, s_ulb_X], dim=0)\n        logits = self._network(inputs)\n        lb_logits = logits[:num_lb]\n        w_ulb_logits, s_ulb_logits = logits[num_lb:].chunk(2)\n        return lb_logits,lb_y,w_ulb_logits, s_ulb_logits\n\n    def get_tsa(self):\n        training_progress = self.it_total / self.num_it_total\n\n        if self.tsa_schedule is None or self.tsa_schedule == 'none':\n            return 1\n        else:\n            if self.tsa_schedule == 'linear':\n                threshold = training_progress\n            elif self.tsa_schedule == 'exp':\n                scale = 5\n                threshold = math.exp((training_progress - 1) * scale)\n            elif self.tsa_schedule == 'log':\n                scale = 5\n                threshold = 1 - math.exp((-training_progress) * scale)\n            else:\n                raise ValueError('Can not get tsa' )\n            tsa = threshold * (1 - 1 / self.num_classes) + 1 / self.num_classes\n            return tsa\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,w_ulb_logits, s_ulb_logits=train_result\n        tsa = self.get_tsa()\n        sup_mask = torch.max(torch.softmax(lb_logits, dim=-1), dim=-1)[0].le(tsa).float().detach()\n        sup_loss = (Cross_Entropy(reduction='none')(lb_logits, lb_y)* sup_mask).mean()  # CE_loss for labeled data\n        pseudo_label = torch.softmax(w_ulb_logits, dim=-1)\n        max_probs, max_idx = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold).float()\n        pseudo_label = torch.softmax(w_ulb_logits / self.T, dim=-1)\n        unsup_loss = (Cross_Entropy(reduction='none',use_hard_labels=False)(s_ulb_logits, pseudo_label)*mask ).mean() # MSE loss for unlabeled data\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss , unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/VAT.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nimport torch\nimport LAMDA_SSL.Config.VAT as config\nfrom LAMDA_SSL.utils import _l2_normalize\nfrom torch.autograd import Variable\nfrom LAMDA_SSL.utils import Bn_Controller\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.KL_Divergence import KL_Divergence\nfrom LAMDA_SSL.Loss.EntMin import EntMin\n\nclass VAT(InductiveEstimator,DeepModelMixin,ClassifierMixin):\n    def __init__(self,\n                 lambda_u=config.lambda_u,\n                 eps=config.eps,\n                 warmup=config.warmup,\n                 it_vat=config.it_vat,\n                 xi=config.xi,\n                 lambda_entmin=config.lambda_entmin,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose):\n        # >> Parameter\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - num_classes: The number of classes.\n        # >> - tsa_schedule: Threshold adjustment strategy, optional 'linear', 'exp' or 'log'.\n        # >> - eps: noise level.\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n        # >> - xi:The scale parameter used when initializing the disturbance variable r, $r=\\xi d$. d is a random unit vector.\n        # >> - lambda_entmin: Entropy minimizes the weight of the loss.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.eps=eps\n        self.it_vat=it_vat\n        self.xi=xi\n        self.lambda_entmin=lambda_entmin\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = ClassifierMixin._estimator_type\n\n\n    def start_fit(self):\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X=lb_X[0] if isinstance(lb_X,(tuple,list)) else lb_X\n        lb_y=lb_y[0] if isinstance(lb_y,(tuple,list)) else lb_y\n        ulb_X = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\n\n        lb_logits = self._network(lb_X)\n\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits = self._network(ulb_X)\n\n        d = torch.Tensor(ulb_X.size()).normal_()\n        for i in range(self.it_vat):\n            d = self.xi*_l2_normalize(d)\n            d = Variable(d.to(self.device), requires_grad=True)\n            y_hat = self._network(ulb_X + d)\n            delta_kl = KL_Divergence(reduction='mean')(ulb_logits.detach(), y_hat)\n            delta_kl.backward()\n            d = d.grad.data.clone()\n            self._network.zero_grad()\n\n        d = _l2_normalize(d)\n        d = Variable(d)\n        r_adv = self.eps * d\n        y_hat = self._network(ulb_X + r_adv.detach())\n\n        self.bn_controller.unfreeze_bn(self._network)\n        return lb_logits,lb_y,ulb_logits, y_hat\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits,y_hat=train_result\n        _warmup = np.clip(self.it_total / (self.warmup * self.num_it_total),\n                a_min=0.0, a_max=1.0)\n\n        sup_loss = Cross_Entropy(reduction='mean')(lb_logits, lb_y)\n\n        unsup_loss = _warmup*KL_Divergence(reduction='mean')(ulb_logits.detach(), y_hat)\n        entmin_loss=EntMin(reduction='mean',activation=torch.nn.Softmax(dim=-1))(ulb_logits)\n\n        loss = sup_loss + self.lambda_u * unsup_loss  + self.lambda_entmin * entmin_loss\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Classification/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Algorithm/Clustering/Constrained_Seed_k_means.py",
    "content": "import numpy as np\nfrom sklearn.base import ClusterMixin\nfrom LAMDA_SSL.Base.TransductiveEstimator import TransductiveEstimator\nimport copy\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.Constrained_Seed_k_means as config\n\nclass Constrained_Seed_k_means(TransductiveEstimator, ClusterMixin):\n    def __init__(self, k=config.k, tolerance=config.tolerance, max_iterations=config.max_iterations,evaluation=config.evaluation,\n                 verbose=config.verbose,file=config.file):\n        # >> Parameter\n        # >> - k: The k value for the k-means clustering algorithm.\n        # >> - tolerance: Tolerance of iterative convergence.\n        # >> - max_iterations: The maximum number of iterations.\n        self.k = k\n        self.tolerance = tolerance\n        self.max_iterations = max_iterations\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.X=None\n        self.y_pred=None\n        self._estimator_type = ClusterMixin._estimator_type\n\n    def fit(self, X, y=None, unlabeled_X=None,clusters=None):\n        assert y is not None or clusters is not None\n        if clusters is None:\n            clusters = {}\n            for _ in range(self.k):\n                clusters[_] = set()\n            for _ in range(len(X)):\n                clusters[y[_]].add(_)\n\n        c=[]\n        for _ in range(self.k):\n            s=clusters[_]\n            l_set=len(s)\n            if l_set==0:\n                raise ValueError('Set is empty!')\n            sum=0\n            for idx in s:\n                sum+=X[idx]\n            sum=sum/l_set\n            c.append(sum)\n        c=np.array(c)\n\n        _X=np.vstack([X,unlabeled_X])\n\n        self.X=_X\n\n        for i in range(self.max_iterations):\n\n            self.clusters = copy.copy(clusters)\n\n            self.unlabeled=[True]*len(_X)\n\n            self.is_clustered=np.array([-1]*len(_X))\n\n            for _ in range(self.k):\n                s = self.clusters[_]\n                for idx in s:\n                    self.is_clustered[idx]=_\n                    self.unlabeled[idx]=False\n\n            unlabeled_idx=np.arange(len(_X))\n            self.unlabeled_set=unlabeled_idx[self.unlabeled]\n\n            for x_index in self.unlabeled_set:\n\n                distances = np.array([np.linalg.norm(_X[x_index] - c[centroid]) for centroid in range(len(c))])\n                r=np.argmin(distances).item()\n\n                self.clusters[r].add(x_index)\n                self.is_clustered[x_index]=r\n\n            previous = c\n\n            for _center in self.clusters:\n                lst = []\n                for index_value in self.clusters[_center]:\n                    lst.append(_X[index_value])\n                avgArr = np.array(lst)\n\n                if len(lst) != 0:\n                    c[_center] = np.average(avgArr, axis=0)\n\n            isOptimal = True\n            for centroid in range(len(c)):\n                original_centroid = previous[centroid]\n                curr = c[centroid]\n                if np.sum((curr - original_centroid) / original_centroid * 100.0) > self.tolerance:\n                    isOptimal = False\n            if isOptimal:\n                break\n\n        self.center = c\n        self.y = self.is_clustered\n        return self\n\n    def predict(self, X=None, Transductive=True):\n        if Transductive:\n            result = self.y\n        else:\n            result = np.array([])\n            for _ in range(len(X)):\n                distances = np.array([np.linalg.norm(X[_] - self.center[centroid]) for centroid in range(len(self.center))])\n                result = np.hstack([result, np.argmin(distances)])\n        return result\n\n    def evaluate(self, X=None, y=None,Transductive=True):\n        if isinstance(X, Dataset) and y is None:\n            y= getattr(X, 'y')\n\n        self.y_pred=self.predict(X,Transductive=Transductive)\n\n        if Transductive:\n            X=self.X\n\n        if self.evaluation is None:\n            return None\n\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,X)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n                performance[key]=val.scoring(y,self.y_pred,X)\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,X)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Clustering/Constrained_k_means.py",
    "content": "import numpy as np\nfrom sklearn.base import ClusterMixin\nfrom LAMDA_SSL.Base.TransductiveEstimator import TransductiveEstimator\nimport random\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.Constrained_k_means as config\n\nclass Constrained_k_means(TransductiveEstimator,ClusterMixin):\n    def __init__(self,k=config.k, tolerance=config.tolerance, max_iterations=config.max_iterations,\n                 evaluation=config.evaluation,verbose=config.verbose,file=config.file):\n        # >> Parameter\n        # >> - k: The k value for the k-means clustering algorithm.\n        # >> - tolerance: Tolerance of iterative convergence.\n        # >> - max_iterations: The maximum number of iterations.\n        self.k=k\n        self.tolerance=tolerance\n        self.max_iterations=max_iterations\n        self.y=None\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.X=None\n        self.y_pred=None\n        self._estimator_type = ClusterMixin._estimator_type\n\n    def fit(self,X,y=None,unlabeled_X=None,cl=None,ml=None):\n        if unlabeled_X is not None:\n            ml = []\n            cl = []\n            for i in range(X.shape[0]):\n                for j in range(i + 1, X.shape[0]):\n                    if y[i] == y[j]:\n                        ml.append({i, j})\n                    else:\n                        cl.append({i, j})\n            X = np.vstack((X, unlabeled_X))\n        self.X=X\n\n        self.ml={}\n        self.cl={}\n        for _ in range(len(X)):\n            self.ml[_]=set()\n            self.cl[_]=set()\n        constrain=np.ones((len(X),len(X)))*-1\n\n        for _ in range(len(cl)):\n            for item1 in cl[_]:\n                for item2 in cl[_]:\n                    if item1!=item2:\n                        constrain[item1][item2]=0\n\n        for _ in range(len(ml)):\n            for item1 in ml[_]:\n                for item2 in ml[_]:\n                    if item1 != item2:\n                        constrain[item1][item2] = -1\n\n        for k in range(len(X)):\n            for i in range(len(X)):\n                for j in range(len(X)):\n                    if i==k or j==k or i==j:\n                        break\n                    if constrain[i][k]==1 and constrain[j][k]==1:\n                        if constrain[i][j]==-1:\n                            constrain[i][j]=constrain[j][i]=1\n                        elif constrain[i][j]==0:\n                            raise ValueError('Can not satisfy constraints.')\n                    if constrain[i][k]==1 and constrain[j][k]==-1:\n                        if constrain[i][j]==-1:\n                            constrain[i][j]=constrain[j][i]=0\n                        elif constrain[i][j] == 1:\n                            raise ValueError('Can not satisfy constraints.')\n                    if constrain[i][k] == -1 and constrain[j][k] == 1:\n                        if constrain[i][j] == -1:\n                            constrain[i][j] = constrain[j][i] = 0\n                        elif constrain[i][j] == 1:\n                            raise ValueError('Can not satisfy constraints.')\n\n        for i in range(len(X)):\n            for j in range(len(X)):\n                if constrain[i][j]==0:\n                    self.cl[i].add(j)\n                if constrain[i][j]==1:\n                    self.ml[i].add(j)\n\n        while True:\n            Find_answer=True\n            index_list = list(range(len(X)))\n\n            random.shuffle(index_list)\n\n            c = X[index_list[:self.k]]\n\n\n            for _ in range(self.max_iterations):\n\n                self.is_clustered = np.array([-1]*len(X))\n\n                self.clusters = {}\n                for i in range(self.k):\n                    self.clusters[i] = set()\n\n                for x_index in range(len(X)):\n\n                    distances = {center_index: np.linalg.norm(X[x_index] - c[center_index])for center_index in range(len(c))}\n\n                    sorted_distances = sorted(distances.items(), key=lambda kv: kv[1])\n\n                    empty_flag = True\n\n                    for center_index,dis_value in sorted_distances:\n\n                        vc_result = self.violate_constraints(x_index, center_index, self.ml, self.cl)\n\n                        if not vc_result:\n                            self.clusters[center_index].add(x_index)\n                            self.is_clustered[x_index] = center_index\n                            for j in self.ml[x_index]:\n                                self.is_clustered[j] = center_index\n                            empty_flag = False\n                            break\n\n                    if empty_flag:\n                        Find_answer=False\n                        break\n                        # raise Exception(\"Clustering Not Found Exception\")\n                if Find_answer is False:\n                    break\n                previous = c\n\n                for _center in self.clusters:\n                    lst = []\n                    for index_value in self.clusters[_center]:\n                        lst.append(X[index_value])\n                    avgArr = np.array(lst)\n\n                    if len(lst) != 0:\n                        c[_center] = np.average(avgArr, axis = 0)\n\n                isOptimal = True\n                for centroid in range(len(c)):\n                    original_centroid = previous[centroid]\n                    curr = c[centroid]\n                    if np.sum((curr - original_centroid)/original_centroid) > self.tolerance:\n                        isOptimal = False\n                if isOptimal:\n                    break\n            if Find_answer:\n                break\n        self.center=c\n        self.y=self.is_clustered\n\n        return self\n\n\n    def violate_constraints(self, data_index, cluster_index, ml, cl):\n        # print(self.clusters)\n        for i in ml[data_index]:\n            if self.is_clustered[i] != -1 and self.is_clustered[i] != cluster_index:\n                return True\n\n        for i in cl[data_index]:\n            if self.is_clustered[i] != -1 and self.is_clustered[i] == cluster_index:\n                # print('cl')\n                # print(i)\n                return True\n        return False\n\n    def predict(self, X=None,Transductive=True):\n        if Transductive:\n            result=self.y\n        else:\n            result=np.array([])\n            for _ in range(len(X)):\n                distances = np.array([np.linalg.norm(X[_] - self.center[centroid]) for centroid in range(len(self.center))])\n                result = np.hstack([result,np.array([np.argmin(distances)])])\n        return  result\n\n    def evaluate(self,X=None,y=None,Transductive=True):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_pred=self.predict(X,Transductive=Transductive)\n\n        if Transductive:\n            X=self.X\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred,X)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred,X)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred,X)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Clustering/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Algorithm/Regression/CoReg.py",
    "content": "import copy\nfrom sklearn.base import RegressorMixin\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.neighbors import KNeighborsRegressor\nfrom sklearn.utils import shuffle\nimport numpy as np\nfrom torch.utils.data.dataset import Dataset\nimport LAMDA_SSL.Config.CoReg as config\n\nclass CoReg(InductiveEstimator,RegressorMixin):\n    def __init__(self, k1=config.k1, k2=config.k2, p1=config.p1, p2=config.p2,\n                 max_iters=config.max_iters, pool_size=config.pool_size,\n                 evaluation=config.evaluation,verbose=config.verbose,file=config.file):\n        # >> Parameter\n        # >> - k1: The k value for the k-nearest neighbors in the first base learner.\n        # >> - k2: The k value for the k-nearest neighbors in the second base learner.\n        # >> - p1: The order of the distance calculated in the first base learner.\n        # >> - p2: The order of the distance calculated in the second base learner.\n        # >> - max_iters: The maximum number of iterations.\n        # >> - pool_size: The size of the buffer pool.\n        self.k1=k1\n        self.k2=k2\n        self.p1=p1\n        self.p2=p2\n        self.max_iters=max_iters\n        self.pool_size=pool_size\n        self.h1 = KNeighborsRegressor(n_neighbors=self.k1, p=self.p1)\n        self.h2 = KNeighborsRegressor(n_neighbors=self.k2, p=self.p2)\n        self.h1_temp = KNeighborsRegressor(n_neighbors=self.k1, p=self.p1)\n        self.h2_temp = KNeighborsRegressor(n_neighbors=self.k2, p=self.p2)\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.y_pred=None\n        self._estimator_type = RegressorMixin._estimator_type\n\n    def fit(self,X,y,unlabeled_X):\n        X1=copy.copy(X)\n        X2=copy.copy(X)\n        y1=copy.copy(y)\n        y2=copy.copy(y)\n        unlabeled_X=copy.copy(unlabeled_X)\n        self.h1.fit(X1, y1)\n        self.h2.fit(X2, y2)\n\n        U_X_pool, U_idx_pool = shuffle(\n            unlabeled_X,  range(unlabeled_X.shape[0]))\n        U_X_pool = U_X_pool[:self.pool_size]\n        U_idx_pool = U_idx_pool[:self.pool_size]\n\n        for _ in range(self.max_iters):\n            stop_training = True\n            added_idxs = []\n            to_remove=[]\n            for idx_h in [1, 2]:\n                if idx_h == 1:\n                    h = self.h1\n                    h_temp = self.h1_temp\n                    L_X, L_y = X1, y1\n                else:\n                    h = self.h2\n                    h_temp = self.h2_temp\n                    L_X, L_y = X2, y2\n                deltas = np.zeros((U_X_pool.shape[0],))\n\n                for idx_u, x_u in enumerate(U_X_pool):\n                    x_u = x_u.reshape(1, -1)\n                    y_u_hat = h.predict(x_u)\n                    omega = h.kneighbors(x_u, return_distance=False)[0]\n                    X_temp = np.concatenate((L_X, x_u))\n                    y_temp = np.concatenate((L_y, y_u_hat))\n                    h_temp.fit(X_temp, y_temp)\n\n                    delta = 0\n                    for idx_o in omega:\n                        delta += (L_y[idx_o].reshape(1, -1) -\n                                  h.predict(L_X[idx_o].reshape(1, -1))) ** 2\n                        delta -= (L_y[idx_o].reshape(1, -1) -\n                                  h_temp.predict(L_X[idx_o].reshape(1, -1))) ** 2\n\n                    deltas[idx_u] = delta\n                sort_idxs = np.argsort(deltas)[::-1]  # max to min\n                max_idx = sort_idxs[0]\n                if max_idx in added_idxs: max_idx = sort_idxs[1]\n                if deltas[max_idx] > 0:\n                    stop_training = False\n                    added_idxs.append(max_idx)\n                    x_u = U_X_pool[max_idx].reshape(1, -1)\n                    y_u_hat = h.predict(x_u)\n                    idx_u=U_idx_pool[max_idx]\n                    to_remove.append(idx_u)\n                    if idx_h == 1:\n                        X1 = np.concatenate((X1, x_u))\n                        y1 = np.concatenate((y1, y_u_hat))\n                    else:\n                        X2 = np.concatenate((X2, x_u))\n                        y2 = np.concatenate((y2, y_u_hat))\n            if stop_training:\n                break\n            else:\n                self.h1.fit(X1, y1)\n                self.h2.fit(X2, y2)\n                unlabeled_X = np.delete(unlabeled_X, to_remove, axis=0)\n                U_X_pool, U_idx_pool = shuffle(\n                    unlabeled_X, range(unlabeled_X.shape[0]))\n                U_X_pool = U_X_pool[:self.pool_size]\n                U_idx_pool = U_idx_pool[:self.pool_size]\n        return self\n\n    def predict(self,X):\n        result1 = self.h1.predict(X)\n        result2 = self.h2.predict(X)\n        result = 0.5 * (result1 + result2)\n        return result\n\n    def evaluate(self,X,y=None):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_pred=self.predict(X)\n\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                score=eval.scoring(y,self.y_pred)\n                if self.verbose:\n                    print(score, file=self.file)\n                performance.append(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n\n                performance[key]=val.scoring(y,self.y_pred)\n\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                self.performance = performance\n            return performance\n        else:\n            performance=self.evaluation.scoring(y,self.y_pred)\n            if self.verbose:\n                print(performance, file=self.file)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Regression/ICTReg.py",
    "content": "from LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import RegressorMixin\nfrom LAMDA_SSL.Loss.MSE import MSE\nimport numpy as np\nimport torch\nfrom LAMDA_SSL.Augmentation.Vision.Mixup import Mixup\nfrom LAMDA_SSL.utils import Bn_Controller\nfrom LAMDA_SSL.Network.MLPReg import MLPReg\nimport torch.nn as nn\nimport copy\nimport LAMDA_SSL.Config.ICTReg as config\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\n\nclass ICTReg(DeepModelMixin,InductiveEstimator,RegressorMixin):\n    def __init__(self,\n                 alpha=config.alpha,\n                 lambda_u=config.lambda_u,\n                 warmup=config.warmup,\n                 dim_in=config.dim_in,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - warmup: Warm up ratio for unsupervised loss.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - alpha: the parameter of Beta distribution in Mixup.\n        # >> - dim_in: the dim of the instances.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.dim_in=dim_in\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.alpha=alpha\n        self.bn_controller=Bn_Controller()\n        self._estimator_type = RegressorMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n\n    def start_fit(self):\n        self.dim_in=self.dim_in if self.dim_in is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[-1]\n        if self.network is None:\n            self.network=MLPReg(hidden_dim=[100, 50, 10], activations=[nn.ReLU(), nn.ReLU(), nn.ReLU()], dim_in=self.dim_in)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_X_1 = ulb_X[0] if isinstance(ulb_X, (tuple, list)) else ulb_X\n        lb_logits = self._network(lb_X)\n        index = torch.randperm(ulb_X_1.size(0)).to(self.device)\n        ulb_X_2=ulb_X_1[index]\n        mixup=Mixup(self.alpha)\n\n        if self.ema is not None:\n            self.ema.apply_shadow()\n        with torch.no_grad():\n            ulb_logits_1 = self._network(ulb_X_1)\n        if self.ema is not None:\n            self.ema.restore()\n        ulb_logits_2=ulb_logits_1[index]\n        mixed_X= mixup.fit(ulb_X_1).transform(ulb_X_2)\n        lam=mixup.lam\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits_mix = self._network(mixed_X)\n        self.bn_controller.unfreeze_bn(self._network)\n        return lb_logits,lb_y,ulb_logits_1,ulb_logits_2,ulb_logits_mix,lam\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits_1,ulb_logits_2,ulb_logits_mix,lam=train_result\n        sup_loss = MSE(reduction='mean')(lb_logits, lb_y)\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup * (lam*MSE(reduction='mean')(ulb_logits_mix,ulb_logits_1)+\n                                (1.0 - lam)*MSE(reduction='mean')(ulb_logits_mix,ulb_logits_2))\n\n        loss =Semi_Supervised_Loss(self.lambda_u)(sup_loss , unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Regression/MeanTeacherReg.py",
    "content": "from LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Loss.MSE import MSE\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nfrom sklearn.base import RegressorMixin\nimport numpy as np\nfrom LAMDA_SSL.utils import Bn_Controller\nfrom LAMDA_SSL.Network.MLPReg import MLPReg\nimport torch.nn as nn\nimport copy\nimport torch\nimport LAMDA_SSL.Config.MeanTeacherReg as config\n\nclass MeanTeacherReg(DeepModelMixin,InductiveEstimator,RegressorMixin):\n    def __init__(self,\n                 dim_in=config.dim_in,\n                 lambda_u=config.lambda_u,\n                 warmup = config.warmup,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - ema_decay: Update weights for the exponential moving average.\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - dim_in: the dim of the instances.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.dim_in=dim_in\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.bn_controller=Bn_Controller()\n\n        self._estimator_type = RegressorMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\n\n    def start_fit(self):\n        self.dim_in=self.dim_in if self.dim_in is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[-1]\n        if self.network is None:\n            self.network=MLPReg(hidden_dim=[100, 50, 10], activations=[nn.ReLU(), nn.ReLU(), nn.ReLU()], dim_in=self.dim_in)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_X_1,ulb_X_2=ulb_X[0],ulb_X[1]\n        lb_logits = self._network(lb_X)\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits_2 = self._network(ulb_X_2)\n        self.bn_controller.unfreeze_bn(self._network)\n        if self.ema is not None:\n            self.ema.apply_shadow()\n        with torch.no_grad():\n            ulb_logits_1 = self._network(ulb_X_1)\n        if self.ema is not None:\n            self.ema.restore()\n        return lb_logits,lb_y,ulb_logits_1,ulb_logits_2\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits_1,ulb_logits_2=train_result\n        sup_loss = MSE()(lb_logits, lb_y)\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup *MSE()(ulb_logits_2, ulb_logits_1.detach())\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss ,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Regression/PiModelReg.py",
    "content": "from LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import RegressorMixin\nfrom LAMDA_SSL.Loss.MSE import MSE\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_Supervised_Loss\nimport numpy as np\nimport copy\nfrom LAMDA_SSL.utils import Bn_Controller\nimport torch.nn as nn\nfrom LAMDA_SSL.Network.MLPReg import MLPReg\nimport LAMDA_SSL.Config.PiModelReg as config\n\nclass PiModelReg(DeepModelMixin,InductiveEstimator,RegressorMixin):\n    def __init__(self,\n                 dim_in=config.dim_in,\n                 lambda_u=config.lambda_u,\n                 warmup=config.warmup,\n                 mu=config.mu,\n                 ema_decay=config.ema_decay,\n                 weight_decay=config.weight_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 evaluation=config.evaluation,\n                 parallel=config.parallel,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        # >> Parameter:\n        # >> - lambda_u: The weight of unsupervised loss.\n        # >> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4,\n        #              then warmup is performed in the first 40 iterations.\n        # >> - dim_in: the dim of the instances.\n        DeepModelMixin.__init__(self,train_dataset=train_dataset,\n                                    valid_dataset=valid_dataset,\n                                    test_dataset=test_dataset,\n                                    train_dataloader=train_dataloader,\n                                    valid_dataloader=valid_dataloader,\n                                    test_dataloader=test_dataloader,\n                                    augmentation=augmentation,\n                                    network=network,\n                                    train_sampler=train_sampler,\n                                    train_batch_sampler=train_batch_sampler,\n                                    valid_sampler=valid_sampler,\n                                    valid_batch_sampler=valid_batch_sampler,\n                                    test_sampler=test_sampler,\n                                    test_batch_sampler=test_batch_sampler,\n                                    labeled_dataset=labeled_dataset,\n                                    unlabeled_dataset=unlabeled_dataset,\n                                    labeled_dataloader=labeled_dataloader,\n                                    unlabeled_dataloader=unlabeled_dataloader,\n                                    labeled_sampler=labeled_sampler,\n                                    unlabeled_sampler=unlabeled_sampler,\n                                    labeled_batch_sampler=labeled_batch_sampler,\n                                    unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                    epoch=epoch,\n                                    num_it_epoch=num_it_epoch,\n                                    num_it_total=num_it_total,\n                                    eval_epoch=eval_epoch,\n                                    eval_it=eval_it,\n                                    mu=mu,\n                                    weight_decay=weight_decay,\n                                    ema_decay=ema_decay,\n                                    optimizer=optimizer,\n                                    scheduler=scheduler,\n                                    device=device,\n                                    evaluation=evaluation,\n                                    parallel=parallel,\n                                    file=file,\n                                    verbose=verbose\n                                    )\n        self.dim_in=dim_in\n        self.ema_decay=ema_decay\n        self.lambda_u=lambda_u\n        self.weight_decay=weight_decay\n        self.warmup=warmup\n        self.bn_controller=Bn_Controller()\n        self.dim_in=None\n        self._estimator_type = RegressorMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.copy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=1,y=0)\n\n    def start_fit(self):\n        self.dim_in=self.dim_in if self.dim_in is not None else \\\n            self._train_dataset.labeled_dataset.X.shape[-1]\n        if self.network is None:\n            self.network=MLPReg(hidden_dim=[100, 50, 10], activations=[nn.ReLU(), nn.ReLU(), nn.ReLU()], dim_in=self.dim_in)\n            self._network=copy.deepcopy(self.network)\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self._network.zero_grad()\n        self._network.train()\n\n    def train(self,lb_X,lb_y,ulb_X,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        ulb_X_1,ulb_X_2=ulb_X[0],ulb_X[1]\n\n        lb_logits = self._network(lb_X)\n        self.bn_controller.freeze_bn(self._network)\n        ulb_logits_1 = self._network(ulb_X_1)\n        ulb_logits_2 = self._network(ulb_X_2)\n        self.bn_controller.unfreeze_bn(self._network)\n        return lb_logits,lb_y,ulb_logits_1,ulb_logits_2\n\n    def get_loss(self,train_result,*args,**kwargs):\n        lb_logits,lb_y,ulb_logits_1,ulb_logits_2=train_result\n        sup_loss = MSE()(lb_logits, lb_y)\n        _warmup = float(np.clip((self.it_total) / (self.warmup * self.num_it_total), 0., 1.))\n        unsup_loss = _warmup *MSE()(ulb_logits_1,ulb_logits_2.detach())\n        loss = Semi_Supervised_Loss(self.lambda_u)(sup_loss ,unsup_loss)\n        return loss\n\n    def predict(self,X=None,valid=None):\n        return DeepModelMixin.predict(self,X=X,valid=valid)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Algorithm/Regression/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Algorithm/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Augmentation/Graph/DropEdges.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nfrom sklearn.utils import check_random_state\nimport numpy as np\n\n\nclass DropEdges(Transformer):\n    def __init__(self, num_drop, shuffle=True, random_state=None):\n        # >> Parameter:\n        # >> - num_drop: The number of edges to be dropped.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - random_state: The random seed.\n        super().__init__()\n        self.num_drop = num_drop\n        self.shuffle = shuffle\n        self.random_state = random_state\n\n    def transform(self, X):\n        num_edges = X.num_edges\n        if self.shuffle:\n            rng = check_random_state(self.random_state)\n            permutation = rng.permutation(num_edges)\n        else:\n            permutation = np.arange(num_edges)\n        ind_drop_edge = permutation[:self.num_drop].tolist()\n        ind_save_edge= permutation[self.num_drop: num_edges].tolist()\n\n        if hasattr(X, 'edge_index')and X.edge_index is not None:\n            X.edge_index = X.edge_index[:,ind_save_edge]\n        if hasattr(X, 'edge_weight')and X.edge_weight is not None:\n            X.edge_weight = X.edge_weight[ind_save_edge]\n        if hasattr(X, 'edge_attr')and X.edge_attr is not None:\n            X.edge_attr = X.edge_attr[ind_save_edge]\n        X.num_edges = len(ind_save_edge)\n\n        return X"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Graph/DropNodes.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nfrom sklearn.utils import check_random_state\nimport numpy as np\nclass DropNodes(Transformer):\n    def __init__(self,num_drop,shuffle=True,random_state=None):\n        # >> Parameter:\n        # >> - num_drop: The number of nodes to be dropped.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - random_state: The random seed.\n        super().__init__()\n        self.num_drop=num_drop\n        self.shuffle=shuffle\n        self.random_state=random_state\n\n    def transform(self,X):\n        num_nodes=X.num_nodes\n        num_edges=X.num_edges\n        if self.shuffle:\n            rng=check_random_state(self.random_state)\n            permutation = rng.permutation(num_nodes)\n        else:\n            permutation = np.arange(num_nodes)\n        ind_drop_node = permutation[:self.num_drop].tolist()\n        ind_save_node = permutation[self.num_drop : num_nodes].tolist()\n\n        ind_drop_edge = []\n        ind_save_edge = []\n\n        edge_index=X.edge_index\n\n        for _ in np.arange(num_edges):\n            s,t=edge_index[0][_],edge_index[1][_]\n            if s in ind_drop_node or t in ind_drop_node:\n                ind_drop_edge.append(_)\n            else:\n                ind_save_edge.append(_)\n\n        if hasattr(X,'x')and X.x is not None:\n            X.x=X.x[ind_save_node]\n        if hasattr(X, 'train_mask')and X.train_mask is not None:\n            X.train_mask=X.train_mask[ind_save_node]\n        if hasattr(X, 'labeled_mask')and X.labeled_mask is not None:\n            X.labeled_mask = X.labeled_mask[ind_save_node]\n        if hasattr(X, 'unlabeled_mask')and X.unlabeled_mask is not None:\n            X.unlabeled_mask=X.unlabeled_mask[ind_save_node]\n        if hasattr(X, 'val_mask')and X.valid_mask is not None:\n            X.valid_mask=X.val_mask[ind_save_node]\n        if hasattr(X, 'test_mask')and X.test_mask is not None:\n            X.test_mask=X.test_mask[ind_save_node]\n        if hasattr(X,'edge_index')and X.edge_index is not None:\n            X.edge_index=X.edge_index[:,ind_save_edge]\n        if hasattr(X, 'edge_attr') and X.edge_attr is not None:\n            X.edge_attr = X.edge_attr[:, ind_save_edge]\n        if hasattr(X,'edge_weight') and X.edge_weight is not None:\n            X.edge_weight=X.edge_weight[ind_save_edge]\n\n        X.num_nodes=len(ind_save_node)\n        X.num_edges=len(ind_save_edge)\n\n        return X"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Graph/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Augmentation/Tabular/Noise.py",
    "content": "import numbers\n\nimport torch\n\nfrom LAMDA_SSL.Base.Transformer import Transformer\nimport numpy as np\n\nclass Noise(Transformer):\n    def __init__(self,noise_level=0.1):\n        super().__init__()\n        # >> Parameter:\n        # >> - noise_level: the level of noise.\n        self.noise_level=noise_level\n\n    def transform(self,X):\n\n        if isinstance(X,torch.Tensor):\n            noise = np.random.normal(loc=0.0, scale=self.noise_level, size=X.size())\n            noise = torch.autograd.Variable(torch.FloatTensor(noise).to(X.device))\n            return X+noise\n        elif isinstance(X,np.ndarray):\n            noise = np.random.normal(loc=0.0, scale=self.noise_level, size=X.shape)\n            return X+noise\n        elif isinstance(X,numbers.Number):\n            noise = np.random.normal(loc=0.0, scale=self.noise_level, size=1)\n            return X+noise\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Tabular/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Augmentation/Text/RandomDeletion.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport random\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\n\nclass RandomDeletion(Transformer):\n    def __init__(self,p=0.5,tokenizer=None):\n        # >> Parameter:\n        # >> - p: The proportion of random deletions.\n        # >> - tokenizer: The tokenizer used when the text is not untokenized.\n        super(RandomDeletion, self).__init__()\n        self.p=p\n        self.tokenizer=tokenizer if tokenizer is not None else Tokenizer('basic_english','en')\n\n    def transform(self,X):\n        tokenized=True\n        if isinstance(X, str):\n            X = self.tokenizer.fit_transform(X)\n            tokenized = False\n        # obviously, if there's only one word, don't delete it\n        if len(X) == 1:\n            return X\n\n        # randomly delete words with probability p\n        new_words = []\n        for word in X:\n            r = random.uniform(0, 1)\n            if r > self.p:\n                new_words.append(word)\n\n        # if you end up deleting all words, just return a random word\n        if len(new_words) == 0:\n            rand_int = random.randint(0, len(X) - 1)\n            new_words=[X[rand_int]]\n        if tokenized is not True:\n            new_words=' '.join(new_words)\n        return new_words\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Text/RandomSwap.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport random\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\n\nclass RandomSwap(Transformer):\n    def __init__(self,n=1,tokenizer=None):\n        # >> Parameter:\n        # >> - n: The number of times to swap words.\n        # >> - tokenizer: The tokenizer used when the text is not untokenized.\n        super(RandomSwap, self).__init__()\n        self.n=n\n        self.tokenizer=tokenizer if tokenizer is not None else Tokenizer('basic_english','en')\n\n    def swap(self,X):\n        random_idx_1 = random.randint(0, len(X) - 1)\n        random_idx_2 = random_idx_1\n        counter = 0\n        while random_idx_2 == random_idx_1:\n            random_idx_2 = random.randint(0, len(X) - 1)\n            counter += 1\n            if counter > 3:\n                return X\n        X[random_idx_1], X[random_idx_2] = X[random_idx_2], X[random_idx_1]\n        return X\n\n    def transform(self,X):\n        tokenized=True\n        if isinstance(X, str):\n            X = self.tokenizer.fit_transform(X)\n            tokenized = False\n        for _ in range(self.n):\n            X = self.swap(X)\n        if tokenized is not True:\n            X=' '.join(X)\n        return X\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Text/TFIDFReplacement.py",
    "content": "import math\nimport numpy as np\nfrom LAMDA_SSL.Base.Transformer import Transformer\nfrom collections import Counter,defaultdict\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\nclass TFIDFReplacement(Transformer):\n    def __init__(self,text,p=0.7,tokenizer=None,cache_len=100000):\n        # >> Parameter:\n        # >> - text: The text that needs to be augmented.\n        # >> - p: Basic replacement probability.\n        # >> - tokenizer: The tokenizer used when the text is not untokenized.\n        # >> - cache_len: buffer size of Random numbers.\n        super(TFIDFReplacement, self).__init__()\n        self.text=text\n        self.p=p\n        self.tokenizer=Tokenizer('basic_english','en') if tokenizer is None else tokenizer\n        self.cache_len=cache_len\n        tot_counter=Counter()\n        idf_counter=Counter()\n        self.len_text=len(text)\n        self.len_tot=0\n        for line in text:\n            if isinstance(line,str):\n                line=self.tokenizer.fit_transform(line)\n            cur_counter=Counter()\n            tot_counter.update(line)\n            cur_counter.update(line)\n            for key,val in cur_counter.items():\n                idf_counter.update([key])\n                self.len_tot+=val\n\n        self.idf={k: math.log((self.len_text+1)/(v+1)) for k,v in idf_counter.items()}\n        self.tf={k:1.0*v/self.len_tot for k,v in tot_counter.items()}\n        self.tf_idf_keys = []\n        self.tf_idf_values = []\n        self.tfidf={}\n        for k, v, in idf_counter.items():\n            self.tfidf[k]=self.idf[k]*self.tf[k]\n            self.tf_idf_keys.append(k)\n            self.tf_idf_values.append(self.tfidf[k])\n        self.normalized_tf_idf = np.array(self.tf_idf_values)\n        self.normalized_tf_idf = (self.normalized_tf_idf.max()\n                                  - self.normalized_tf_idf)\n        self.normalized_tf_idf = (self.normalized_tf_idf\n                                  / self.normalized_tf_idf.sum())\n        self.reset_token_list()\n        self.reset_random_prob()\n\n    def reset_random_prob(self):\n        \"\"\"Generate many random numbers at the same time and cache them.\"\"\"\n        self.random_prob_cache = np.random.random(size=(self.cache_len,))\n        self.random_prob_ptr = self.cache_len - 1\n\n    def reset_token_list(self):\n        cache_len = len(self.tf_idf_keys)\n        token_list_idx = np.random.choice(\n            cache_len, (cache_len,), p=self.normalized_tf_idf)\n        self.token_list = []\n        for idx in token_list_idx:\n            self.token_list += [self.tf_idf_keys[idx]]\n        self.token_ptr = len(self.token_list) - 1\n\n    def get_random_prob(self):\n        \"\"\"Get a random number.\"\"\"\n        value = self.random_prob_cache[self.random_prob_ptr]\n        self.random_prob_ptr -= 1\n        if self.random_prob_ptr == -1:\n            self.reset_random_prob()\n        return value\n\n    def get_random_token(self):\n        \"\"\"Get a random token.\"\"\"\n        token = self.token_list[self.token_ptr]\n        self.token_ptr -= 1\n        if self.token_ptr == -1:\n            self.reset_token_list()\n        return token\n\n    def get_replace_prob(self, X):\n        cur_tf_idf = defaultdict(int)\n        for word in X:\n            cur_tf_idf[word] += 1. / len(X) * self.idf[word] if word in self.idf.keys() else 1. / len(X) *math.log(self.len_text)\n        replace_prob = []\n        for word in X:\n            replace_prob += [cur_tf_idf[word]]\n        replace_prob = np.array(replace_prob)\n        replace_prob = np.max(replace_prob) - replace_prob\n        replace_prob = replace_prob / replace_prob.sum() *self.p * len(X)\n        for _ in range(len(replace_prob)):\n            replace_prob[_]=min(1,replace_prob[_])\n        return replace_prob\n\n    def replace_tokens(self, word_list, replace_prob):\n        \"\"\"Replace tokens in a sentence.\"\"\"\n        for i in range(len(word_list)):\n            if self.get_random_prob() < replace_prob[i]:\n                word_list[i] = self.get_random_token()\n        return word_list\n\n    def transform(self,X):\n        tokenized=True\n        if isinstance(X, str):\n            X = self.tokenizer.fit_transform(X)\n            tokenized = False\n        replace_prob = self.get_replace_prob(X)\n        X = self.replace_tokens(\n            X,\n            replace_prob\n        )\n        if not tokenized:\n            X=' '.join(X)\n        return X\n\n\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Text/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/AutoContrast.py",
    "content": "from LAMDA_SSL.Base.Transformer import  Transformer\nimport torchvision.transforms.functional as F\nimport PIL\nimport torch\nimport numpy as np\n\nclass AutoContrast(Transformer):\n    def __init__(self):\n        super().__init__()\n\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            X=PIL.ImageOps.autocontrast(X)\n            return X\n        elif isinstance(X,torch.Tensor):\n            X = F.autocontrast(X)\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Brightness.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport torch\nimport PIL\nimport numpy as np\n\nclass Brightness(Transformer):\n    def __init__(self, min_v=0.05,max_v=0.95,num_bins=10,magnitude=5,v=None):\n        super().__init__()\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            # _v = self.v if random.random() < 0.5 else self.v * -1\n            _v = self.v\n            X=PIL.ImageEnhance.Brightness(X).enhance(_v)\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    # _v = self.v if random.random() < 0.5 else self.v * -1\n                    _v = self.v\n                    X[_]=F.adjust_brightness(X[_],_v)\n            else:\n                # _v = self.v if random.random() < 0.5 else self.v * -1\n                _v = self.v\n                X = F.adjust_brightness(X,_v)\n            return X\n        else:\n            raise ValueError('No data to augment')\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/CenterCrop.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nfrom torchvision import transforms\r\nfrom LAMDA_SSL.utils import partial\r\nimport PIL\r\nimport numpy as np\r\nimport torch\r\n\r\nclass CenterCrop(Transformer):\r\n    def __init__(self):\r\n        # >> Parameter:\r\n        # >> - padding: Optional padding on each border of the image. Default is None. If a single int is provided this is used to pad all borders. If sequence of length 2 is provided this is the padding on left/right and top/bottom respectively. If a sequence of length 4 is provided this is the padding for the left, top, right and bottom borders respectively.\r\n        # >> - pad_if_needed: It will pad the image if smaller than the desired size to avoid raising an exception. Since cropping is done after padding, the padding seems to be done at a random offset.\r\n        # >> - fill: Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. Only number is supported for torch Tensor. Only int or str or tuple value is supported for PIL Image.\r\n        # >> - padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant.\r\n        super().__init__()\r\n        #self.padding=padding\r\n        #self.pad_if_needed=pad_if_needed\r\n        #self.fill=fill\r\n        #self.padding_mode=padding_mode\r\n        self.augmentation=transforms.CenterCrop\r\n                                    #fill=fill,padding_mode=padding_mode)\r\n    def transform(self,X):\r\n        if isinstance(X,np.ndarray):\r\n            X=PIL.Image.fromarray(X)\r\n        if isinstance(X,PIL.Image.Image):\r\n            size=X.size[0]\r\n            #padding=int(self.padding*size) if self.padding is not None else None\r\n            augmentation = self.augmentation(size=size)\r\n            X = augmentation(X)\r\n            return X\r\n        elif isinstance(X,torch.Tensor):\r\n            size=X.shape[-2]\r\n            #padding=int(self.padding*size) if self.padding is not None else None\r\n            if len(X.shape)==4:\r\n                for _ in range(X.shape[0]):\r\n                    augmentation = self.augmentation(size=size)\r\n                    X[_]=augmentation(X[_])\r\n            else:\r\n                augmentation = self.augmentation(size=size)\r\n                X = augmentation(X)\r\n            return X\r\n        else:\r\n            raise ValueError('No data to augment')\r\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Color.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport torch\nimport PIL\nimport numpy as np\n\n\nclass Color(Transformer):\n    def __init__(self, min_v=0.05,max_v=0.95,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            # _v = self.v if random.random() < 0.5 else self.v * -1\n            _v = self.v\n            X=PIL.ImageEnhance.Color(X).enhance(_v)\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    # _v = self.v if random.random() < 0.5 else self.v * -1\n                    _v = self.v\n                    X[_]=F.adjust_saturation(X[_],_v)\n            else:\n                # _v = self.v if random.random() < 0.5 else self.v * -1\n                _v = self.v\n                X = F.adjust_saturation(X,_v)\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Contrast.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport torch\nimport PIL\nimport numpy as np\n\nclass Contrast(Transformer):\n    def __init__(self, min_v=0.05,max_v=0.95,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            # _v = self.v if random.random() < 0.5 else self.v * -1\n            _v = self.v\n            X=PIL.ImageEnhance.Contrast(X).enhance(_v)\n            return X\n        elif isinstance(X,torch.Tensor):\n\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    # _v = self.v if random.random() < 0.5 else self.v * -1\n                    _v = self.v\n                    X[_]=F.adjust_contrast(X[_],_v)\n            else:\n                # _v = self.v if random.random() < 0.5 else self.v * -1\n                _v = self.v\n                X = F.adjust_contrast(X,_v)\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Cutout.py",
    "content": "import PIL,PIL.ImageEnhance\nimport torch\n\nfrom LAMDA_SSL.Base.Transformer import Transformer\nfrom LAMDA_SSL.Augmentation.Vision.CutoutAbs import CutoutAbs\nimport numpy as np\n\nclass Cutout(Transformer):\n    def __init__(self, v=0.5,fill=(127,127,127),random_v=True):\n        # >> Parameter:\n        # >> - v: The relative value of crop size.\n        # >> - fill: The padding value.\n        # >> - random_v: Whether to randomly determine the crop size.\n        super().__init__()\n        self.v=v\n        self.fill=fill\n        self.random_v=random_v\n        assert 0.0 <= v <= 0.5\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            v = self.v * X.size[0]\n        elif isinstance(X,torch.Tensor):\n            v = self.v * X.shape[-2]\n        else:\n            raise ValueError('No data to augment')\n        X=CutoutAbs(v,self.fill,self.random_v).fit_transform(X)\n\n        return X\n\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/CutoutAbs.py",
    "content": "import copy\nimport numbers\nimport random\n\nimport PIL.Image\n\nfrom LAMDA_SSL.Base.Transformer import Transformer\n\nimport numpy as np\nimport torch\n\nclass CutoutAbs(Transformer):\n    def __init__(self, v=16,fill=(127,127,127),random_v=True):\n        # >> Parameter:\n        # >> - v: The absolute value of the crop size.\n        # >> - fill: The padding value.\n        # >> - random_v: Whether to randomly determine the crop size.\n        super().__init__()\n        self.v=v\n        self.random_v=random_v\n        if isinstance(self.v, (tuple, list)):\n            self.vx, self.vy = self.v[0], self.v[1]\n        else:\n            self.vx, self.vy = self.v, self.v\n\n        if isinstance(fill,numbers.Number):\n            self.fill = (fill, fill, fill)\n        else:\n            self.fill=fill\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            w, h = X.size[0], X.size[1]\n            x0 = np.random.uniform(w)\n            y0 = np.random.uniform(h)\n            rd=random.random() if self.random_v else 1\n            vx=self.vx *rd\n            vy = self.vy * rd\n            x0 = int(max(0, x0 - vx / 2.))\n            y0 = int(max(0, y0 - vy / 2.))\n            x1 = int(min(w, x0 + vx))\n            y1 = int(min(h, y0 + vy))\n            xy = (x0, y0, x1, y1)\n            PIL.ImageDraw.Draw(X).rectangle(xy, self.fill)\n            return X\n\n        elif isinstance(X,torch.Tensor):\n            X=copy.copy(X)\n            X_shape=X.shape\n            if self.fill is None:\n                self.fill=(0,0,0)\n            w, h = X_shape[-2],X_shape[-1]\n            if len(X_shape) == 4:\n\n                for _ in range(X.shape[0]):\n                    x0 = np.random.uniform(w)\n                    y0 = np.random.uniform(h)\n                    rd = random.random() if self.random_v else 1\n                    vx = self.vx * rd\n                    vy = self.vy * rd\n                    x0 = int(max(0, x0 - vx / 2.))\n                    y0 = int(max(0, y0 - vy  / 2.))\n                    x1 = int(min(w, x0 + vx ))\n                    y1 = int(min(h, y0 + vy ))\n\n                    X[_, 0, x0:x1, y0:y1].copy_(torch.Tensor([self.fill[0]]))\n                    X[_, 1, x0:x1, y0:y1].copy_(torch.Tensor([self.fill[1]]))\n                    X[_, 2, x0:x1, y0:y1].copy_(torch.Tensor([self.fill[2]]))\n            else:\n                x0 = np.random.uniform(w)\n                y0 = np.random.uniform(h)\n                rd = random.random() if self.random_v else 1\n                vx = self.vx * rd\n                vy = self.vy * rd\n                x0 = int(max(0, x0 - vx / 2.))\n                y0 = int(max(0, y0 - vy / 2.))\n                x1 = int(min(w, x0 + vx))\n                y1 = int(min(h, y0 + vy))\n                # print('???')\n                X[0,x0:x1,y0:y1].copy_(torch.Tensor([self.fill[0]]))\n                X[1,x0:x1,y0:y1].copy_(torch.Tensor([self.fill[1]]))\n                X[2,x0:x1,y0:y1].copy_(torch.Tensor([self.fill[2]]))\n\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Equalize.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport PIL\nimport torch\nimport numpy as np\n\nclass Equalize(Transformer):\n    def __init__(self,scale=255):\n        # >> Parameter:\n        # >> - scale: Scale of image pixel values\n        super().__init__()\n        self.scale=scale\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X, PIL.Image.Image):\n            X = PIL.ImageOps.equalize(X)\n            return X\n        elif isinstance(X, torch.Tensor):\n            X = F.equalize((X * self.scale).type(torch.uint8)) / self.scale\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Identity.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\n\nclass Identity(Transformer):\n    def __init__(self):\n        super().__init__()\n\n    def transform(self,X):\n        if X is not None:\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Invert.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport PIL\nimport torch\nimport numpy as np\n\nclass Invert(Transformer):\n    def __init__(self):\n        super().__init__()\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            X=PIL.ImageOps.invert(X)\n            return X\n        elif isinstance(X,torch.Tensor):\n            X = F.invert(X)\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Mixup.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport numpy as np\n\nclass Mixup(Transformer):\n    def __init__(self, alpha=0.5):\n        # >> Parameter:\n        # >> - alpha: The parameter of the beta distribution.\n        super().__init__()\n        self.alpha = alpha\n        self.lam=None\n        self.X=None\n\n    def fit(self,X,y=None,**fit_params):\n        self.X=X\n        self.y=y\n        return self\n\n    def transform(self,X):\n        self.lam = np.random.beta(self.alpha, self.alpha)\n        if self.y is not None and isinstance(X,(list,tuple)):\n            X,y=X[0],X[1]\n            X = self.lam * self.X + (1 - self.lam) * X\n            y = self.lam * self.y + (1 - self.lam) * y\n            return X,y\n        else:\n            if isinstance(X,(list,tuple)):\n                X=type(X)(self.lam * self.X[i]+(1 - self.lam) * X[i] for i in range(len(X)))\n            else:\n                X=self.lam * self.X+(1 - self.lam) * X\n            return X\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Posterize.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport torch\nimport PIL\nimport numpy as np\n\nclass Posterize(Transformer):\n    def __init__(self, min_v=4,max_v=8,num_bins=10,magnitude=5,v=None,scale=255):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        # >> - scale: Scale of image pixel values\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=self.max_v - (torch.arange(self.num_bins) / ((self.num_bins - 1) / self.min_v)).round().int()\n        self.v=self.magnitudes[self.magnitude].item()if v is None else v\n        self.scale=scale\n        self.v = int(max(1, self.v))\n\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            X=PIL.ImageOps.posterize(X, self.v)\n            return X\n        elif isinstance(X,torch.Tensor):\n            X=F.posterize((X*self.scale).type(torch.uint8), self.v)/self.scale\n            return X\n        else:\n            raise ValueError('No data to augment')\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/RandAugment.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport numpy as np\nimport random\nimport PIL\n\ndef AutoContrast(X, **kwarg):\n    return PIL.ImageOps.autocontrast(X)\n\n\ndef Brightness(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    return PIL.ImageEnhance.Brightness(X).enhance(v)\n\n\ndef Color(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    return PIL.ImageEnhance.Color(X).enhance(v)\n\n\ndef Contrast(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    return PIL.ImageEnhance.Contrast(X).enhance(v)\n\ndef Equalize(X, **kwarg):\n    return PIL.ImageOps.equalize(X)\n\n\ndef Identity(X, **kwarg):\n    return X\n\n\ndef Invert(X, **kwarg):\n    return PIL.ImageOps.invert(X)\n\n\ndef Posterize(X, min_v, max_v,magnitude,num_bins=10):\n    v = int(min_v+(max_v -min_v) * magnitude/ num_bins)\n    return PIL.ImageOps.posterize(X, v)\n\n\ndef Rotate(X, min_v, max_v,magnitude,num_bins=10):\n    v = int(min_v+(max_v -min_v) * magnitude/ num_bins)\n    if random.random() < 0.5:\n        v = -v\n    return X.rotate(v)\n\n\ndef Sharpness(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    return PIL.ImageEnhance.Sharpness(X).enhance(v)\n\n\ndef ShearX(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    if random.random() < 0.5:\n        v = -v\n    return X.transform(X.size, PIL.Image.AFFINE, (1, v, 0, 0, 1, 0))\n\n\ndef ShearY(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    if random.random() < 0.5:\n        v = -v\n    return X.transform(X.size, PIL.Image.AFFINE, (1, 0, 0, v, 1, 0))\n\n\ndef Solarize(X, min_v, max_v,magnitude,num_bins=10):\n    v = int(min_v+(max_v -min_v) * magnitude/ num_bins)\n    return PIL.ImageOps.solarize(X, 256 - v)\n\n\n\ndef TranslateX(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    if random.random() < 0.5:\n        v = -v\n    v = int(v * X.size[0])\n    return X.transform(X.size, PIL.Image.AFFINE, (1, 0, v, 0, 1, 0))\n\n\ndef TranslateY(X, min_v, max_v,magnitude,num_bins=10):\n    v = min_v+float(max_v -min_v) * magnitude/ num_bins\n    if random.random() < 0.5:\n        v = -v\n    v = int(v * X.size[1])\n    return X.transform(X.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, v))\n\nclass RandAugment(Transformer):\n    def __init__(self, n=2, m=5, num_bins=10, random=True,augment_list=None):\n        # >> Parameter:\n        # >> - n: The times of Random augmentation.\n        # >> - m: The magnitude of Random augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - random: Whether to use random value for augmentation.\n        # >> - augment_list: The list of augmentations and their minimum and maximum values.\n        super().__init__()\n        self.n = n\n        self.m = m\n        self.num_bins=num_bins\n        self.random=random\n        self.augment_list =[(AutoContrast, None, None),\n            (Brightness, 0.05, 0.95),\n            (Color, 0.05, 0.95),\n            (Contrast, 0.05, 0.95),\n            (Equalize, None, None),\n            (Identity, None, None),\n            (Posterize, 4, 8),\n            (Rotate,  0.0,30.0),\n            (Sharpness, 0.05, 0.95),\n            (ShearX, 0.0, 0.3),\n            (ShearY, 0.0, 0.3),\n            (Solarize,  0.0,256.0),\n            (TranslateX, 0.0, 0.3),\n            (TranslateY, 0.0, 0.3)] if augment_list is None else augment_list\n\n    def transform(self, X):\n        ops = random.choices(self.augment_list, k=self.n)\n        for op, min_v, max_v in ops:\n            if self.random:\n                m = np.random.randint(1, self.m)\n            else:\n                m=self.m\n            if random.random() < 0.5:\n                X=op(X=X,min_v=min_v,max_v=max_v,num_bins=self.num_bins,magnitude=m)\n        return X"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/RandomCrop.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nfrom torchvision import transforms\nfrom LAMDA_SSL.utils import partial\nimport PIL\nimport numpy as np\nimport torch\n\nclass RandomCrop(Transformer):\n    def __init__(self, padding=None, pad_if_needed=False, fill=0, padding_mode=\"constant\"):\n        # >> Parameter:\n        # >> - padding: Optional padding on each border of the image. Default is None. If a single int is provided this is used to pad all borders. If sequence of length 2 is provided this is the padding on left/right and top/bottom respectively. If a sequence of length 4 is provided this is the padding for the left, top, right and bottom borders respectively.\n        # >> - pad_if_needed: It will pad the image if smaller than the desired size to avoid raising an exception. Since cropping is done after padding, the padding seems to be done at a random offset.\n        # >> - fill: Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. Only number is supported for torch Tensor. Only int or str or tuple value is supported for PIL Image.\n        # >> - padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant.\n        super().__init__()\n        self.padding=padding\n        self.pad_if_needed=pad_if_needed\n        self.fill=fill\n        self.padding_mode=padding_mode\n        self.augmentation=partial(transforms.RandomCrop,pad_if_needed=pad_if_needed,\n                                    fill=fill,padding_mode=padding_mode)\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            size=X.size[0]\n            padding=int(self.padding*size) if self.padding is not None else None\n            augmentation = self.augmentation(size=size, padding=padding)\n            X = augmentation(X)\n            return X\n        elif isinstance(X,torch.Tensor):\n            size=X.shape[-2]\n            padding=int(self.padding*size) if self.padding is not None else None\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    augmentation = self.augmentation(size=size, padding=padding)\n                    X[_]=augmentation(X[_])\n            else:\n                augmentation = self.augmentation(size=size, padding=padding)\n                X = augmentation(X)\n            return X\n        else:\n            raise ValueError('No data to augment')\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/RandomHorizontalFlip.py",
    "content": "import torch\nimport numpy as np\nfrom LAMDA_SSL.Base.Transformer import Transformer\nfrom torchvision import transforms\nimport PIL.Image\n\nclass RandomHorizontalFlip(Transformer):\n    def __init__(self):\n        super().__init__()\n        self.augmentation=transforms.RandomHorizontalFlip()\n\n    def transform(self,X=None):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            X = self.augmentation(X)\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    X[_]=self.augmentation(X[_])\n            else:\n                X = self.augmentation(X)\n            return X\n        else:\n            raise ValueError('No data to augment')\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Rotate.py",
    "content": "import torch\nimport numpy as np\nimport PIL\nfrom LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport random\n\nclass Rotate(Transformer):\n    def __init__(self, min_v=0,max_v=30,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        if v is None:\n            self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n            self.v = float(self.magnitudes[self.magnitude].item())\n        else:\n            self.v=v\n\n    def transform(self,X,rand=False):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            _v=self.v if random.random() < 0.5 else self.v*-1\n            X=X.rotate(_v)\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    _v = self.v if random.random() < 0.5 else self.v * -1\n                    X[_]=F.rotate(X[_],_v)\n            else:\n                _v = self.v if random.random() < 0.5 else self.v * -1\n                X = F.rotate(X,_v)\n            return X\n\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Sharpness.py",
    "content": "import numpy as np\n\nfrom LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport torch\nimport PIL\n\nclass Sharpness(Transformer):\n    def __init__(self, min_v=0.05,max_v=0.95,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            # _v = self.v if random.random() < 0.5 else self.v * -1\n            _v = self.v\n            X=PIL.ImageEnhance.Sharpness(X).enhance(_v)\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    # _v = self.v if random.random() < 0.5 else self.v * -1\n                    _v = self.v\n                    X[_]=F.adjust_sharpness(X[_],_v)\n            else:\n                # _v = self.v if random.random() < 0.5 else self.v * -1\n                _v = self.v\n                X = F.adjust_sharpness(X,_v)\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/ShearX.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport math\nimport random\nimport torch\nimport PIL\nimport numpy as np\n\nclass ShearX(Transformer):\n    def __init__(self, min_v=0,max_v=0.3,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            _v = self.v if random.random() < 0.5 else self.v * -1\n            X=X.transform(X.size, PIL.Image.AFFINE, (1, _v, 0, 0, 1, 0))\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    _v = self.v if random.random() < 0.5 else self.v * -1\n                    X[_]=F.affine(X[_],angle=0,translate=[0, 0],scale=1.0,shear=[math.degrees(_v),0.0])\n            else:\n                _v = self.v if random.random() < 0.5 else self.v * -1\n                X=F.affine(X,angle=0,translate=[0, 0],scale=1.0,shear=[math.degrees(_v),0.0])\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/ShearY.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport math\nimport random\nimport torch\nimport PIL\nimport numpy as np\n\nclass ShearY(Transformer):\n    def __init__(self, min_v=0,max_v=0.3,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            _v = self.v if random.random() < 0.5 else self.v * -1\n            X=X.transform(X.size, PIL.Image.AFFINE, (1, 0, 0, _v, 1, 0))\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    _v = self.v if random.random() < 0.5 else self.v * -1\n                    X[_]=F.affine(X[_],angle=0,translate=[0, 0],scale=1.0,shear=[0.0,math.degrees(_v)])\n            else:\n                _v = self.v if random.random() < 0.5 else self.v * -1\n                X=F.affine(X,angle=0,translate=[0, 0],scale=1.0,shear=[0.0,math.degrees(_v)])\n            return X\n        else:\n            raise ValueError('No data to augment')\n"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/Solarize.py",
    "content": "import PIL.Image\nimport torch\nimport numpy as np\nfrom LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\n\nclass Solarize(Transformer):\n    def __init__(self, min_v=0,max_v=255,num_bins=10,magnitude=5,v=None,scale=256):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        # >> - scale: Scale of image pixel values\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(self.max_v, self.min_v, self.num_bins)\n        self.scale=scale\n        self.v=float(self.magnitudes[self.magnitude-1].item()) if v is None else v\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            X=PIL.ImageOps.solarize(X, self.scale-self.v)\n            return X\n        elif isinstance(X,torch.Tensor):\n            X = F.solarize((X * (self.scale-1)).ceil().type(torch.uint8),self.scale-self.v) / self.scale\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/TranslateX.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport random\nimport torch\nimport PIL\nimport numpy as np\n\nclass TranslateX(Transformer):\n    def __init__(self, min_v=0,max_v=0.3,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            _v = self.v if random.random() < 0.5 else self.v * -1\n            _v = int(_v * X.size[0])\n            X=X.transform(X.size, PIL.Image.AFFINE, (1, 0, _v, 0, 1, 0))\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    _v = self.v if random.random() < 0.5 else self.v * -1\n                    _v = int(_v* X.shape[-2])\n                    X[_]=F.affine(X[_], angle=0, translate=[_v, 0], scale=1.0, shear=[0.0, 0.0])\n            else:\n                _v = self.v if random.random() < 0.5 else self.v * -1\n                _v = int(_v * X.shape[-2])\n                X=F.affine(X, angle=0, translate=[_v, 0], scale=1.0, shear=[0.0, 0.0])\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/TranslateY.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport random\nimport torch\nimport PIL\nimport numpy as np\n\nclass TranslateY(Transformer):\n    def __init__(self, min_v=0,max_v=0.3,num_bins=10,magnitude=5,v=None):\n        # >> Parameter:\n        # >> - min_v: The minimum value of the augmentation.\n        # >> - max_v: The maximum value of the augmentation.\n        # >> - num_bins: The number of intervals  division for the value of the augmentation.\n        # >> - magnitude: The level of the augmentation.\n        # >> - v: Specify the value of the augmentation directly.\n        super().__init__()\n        self.max_v=max_v\n        self.min_v=min_v\n        self.num_bins=num_bins\n        self.magnitude=magnitude\n        self.magnitudes=torch.linspace(min_v, max_v, num_bins)\n        self.v=float(self.magnitudes[self.magnitude].item())if v is None else v\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        if isinstance(X,PIL.Image.Image):\n            _v = self.v if random.random() < 0.5 else self.v * -1\n            _v = int(_v * X.size[1])\n            X=X.transform(X.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, _v))\n            return X\n        elif isinstance(X,torch.Tensor):\n            if len(X.shape)==4:\n                for _ in range(X.shape[0]):\n                    _v = self.v if random.random() < 0.5 else self.v * -1\n                    _v = int(_v* X.shape[-1])\n                    X[_]=F.affine(X[_], angle=0, translate=[0,_v], scale=1.0, shear=[0.0, 0.0])\n            else:\n                _v = self.v if random.random() < 0.5 else self.v * -1\n                _v = int(_v * X.shape[-1])\n                X=F.affine(X, angle=0, translate=[0,_v], scale=1.0, shear=[0.0, 0.0])\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Augmentation/Vision/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Augmentation/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Base/BaseOptimizer.py",
    "content": "from torch.optim.optimizer import Optimizer\nclass BaseOptimizer:\n    def __init__(self,defaults):\n        # >> - defaults: A dict containing default values of optimization options (used when a parameter group doesn't specify them).\n        self.defaults=defaults\n    def init_optimizer(self,params):\n        # >> init_optimizer(params): Put the parameters that need to be optimized into the optimizer.\n        # >> - params: The parameters to be optimized.\n        return Optimizer(params=params,default=self.defaults)\n\n"
  },
  {
    "path": "LAMDA_SSL/Base/BaseSampler.py",
    "content": "from torch.utils.data.sampler import Sampler\nclass BaseSampler:\n    def __init__(self):\n        pass\n    def init_sampler(self,data_source):\n        # >> init_sampler(data_source):  Initialize the sampler with data.\n        # >> - data_source: The data to be sampled.\n        return Sampler(data_source=data_source)\n"
  },
  {
    "path": "LAMDA_SSL/Base/BaseScheduler.py",
    "content": "from torch.optim import lr_scheduler\nclass BaseScheduler:\n    def __init__(self, last_epoch=-1, verbose=False):\n        # >> Parameter:\n        # >> - last_epoch: The index of last epoch.\n        # >> - verbose: If 'True', prints a message to stdout for each update.\n        self.last_epoch=last_epoch\n        self.verbose=verbose\n\n    def init_scheduler(self,optimizer):\n        # >> init_scheduler(optimizer): Initialize the scheduler with the optimizer.\n        # >> - optimizer: The optimizer used by the model.\n        return lr_scheduler._LRScheduler(optimizer,last_epoch=self.last_epoch,verbose=self.verbose)\n"
  },
  {
    "path": "LAMDA_SSL/Base/ClassifierEvaluation.py",
    "content": "from abc import ABC,abstractmethod\n\nclass ClassifierEvaluation(ABC):\n    def __init__(self):\n        pass\n    @abstractmethod\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        # >> scoring(y_true,y_pred=None,y_score=None): Initialize the data transformation method.\n        # >> - y_true: Ground-truth labels.\n        # >> - y_pred: Hard labels for model predictions.\n        # >> - y_score: Soft labels for model predictions.\n        raise NotImplementedError"
  },
  {
    "path": "LAMDA_SSL/Base/ClusterEvaluation.py",
    "content": "from abc import ABC,abstractmethod\nclass ClusterEvaluation(ABC):\n    def __init__(self):\n        pass\n    @abstractmethod\n    def scoring(self,y_true=None,clusters=None,X=None):\n        # > scoring(y_true=None,clusters=None,X=None): Initialize the data transformation method.\n        # >> - y_true: Ground-truth labels.\n        # >> - clusters: Clustering results.\n        # >> - X: Sample features used in clustering.\n        raise NotImplementedError"
  },
  {
    "path": "LAMDA_SSL/Base/DeepModelMixin.py",
    "content": "import copy\nfrom math import ceil\nimport torch\nfrom LAMDA_SSL.Base.SemiEstimator import SemiEstimator\nfrom torch.utils.data.dataset import Dataset\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\n\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\n\nfrom LAMDA_SSL.utils import EMA\nfrom LAMDA_SSL.utils import to_device\nfrom torch.nn import Softmax\nfrom LAMDA_SSL.Dataloader.TrainDataloader import TrainDataLoader\n\nclass DeepModelMixin(SemiEstimator):\n    def __init__(self, train_dataset=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None,\n                 verbose=True\n                 ):\n        # >> Parameter\n        # >> - train_dataset: Data manager for training data.\n        # >> - labeled_dataset: Data manager for labeled data.\n        # >> - unlabeled_dataset: Data manager for unlabeled data.\n        # >> - valid_dataset: Data manager for valid data.\n        # >> - test_dataset: Data manager for test data.\n        # >> - augmentation: Augmentation method, if there are multiple augmentation methods, you can use a dictionary or a list to pass parameters.\n        # >> - network: The backbone neural network.\n        # >> - epoch: Number of training epochs.\n        # >> - num_it_epoch: The number of iterations in each round, that is, the number of batches of data.\n        # >> - num_it_total: The total number of batches.\n        # >> - eval_epoch: Model evaluation is performed every eval_epoch epochs.\n        # >> - eval_it: Model evaluation is performed every eval_it iterations.\n        # >> - mu: The ratio of the number of unlabeled data to the number of labeled data.\n        # >> - optimizer: The optimizer used in training.\n        # >> - weight_decay: The optimizer's learning rate decay parameter.\n        # >> - ema_decay: The update scale for the exponential moving average of the model parameters.\n        # >> - scheduler: Learning rate scheduler.\n        # >> - device: Training equipment.\n        # >> - evaluation: Model evaluation metrics. If there are multiple metrics, a dictionary or a list can be used.\n        # >> - train_sampler: Sampler of training data.\n        # >> - labeled_sampler=None: Sampler of labeled data.\n        # >> - unlabeled_sampler=None: Sampler of unlabeled data.\n        # >> - train_batch_sampler=None: Batch sampler of training data\n        # >> - labeled_batch_sampler: Batch sampler of labeled data\n        # >> - unlabeled_batch_sampler: Batch sampler of unlabeled data\n        # >> - valid_sampler: sampler of valid data.\n        # >> - valid_batch_sampler: Batch sampler of valid data.\n        # >> - test_sampler: Sampler of test data.\n        # >> - test_batch_sampler: Batch sampler of test data.\n        # >> - parallel: Distributed training method.\n        # >> - file: Output file.\n        self.train_dataset=train_dataset if train_dataset is not None else TrainDataset(labeled_dataset=labeled_dataset,\n                                                                                        unlabeled_dataset=unlabeled_dataset)\n        self.labeled_dataset=labeled_dataset\n        self.unlabeled_dataset=unlabeled_dataset\n        self.valid_dataset = valid_dataset if valid_dataset is not None else test_dataset\n        self.test_dataset=test_dataset\n        self.train_dataloader=train_dataloader\n        self.labeled_dataloader=labeled_dataloader\n        self.unlabeled_dataloader=unlabeled_dataloader\n        self.valid_dataloader=valid_dataloader if valid_dataloader is not None else test_dataloader\n        self.test_dataloader=test_dataloader\n        self.augmentation=augmentation\n        self.network=network\n        self.epoch=epoch\n        self.mu=mu\n        self.optimizer=optimizer\n        self.scheduler=scheduler\n        self.device=device\n        self.eval_epoch=eval_epoch\n        self.eval_it=eval_it\n        self.weight_decay=weight_decay\n        self.ema_decay=ema_decay\n        self.y_est=None\n        self.y_true=None\n        self.y_pred=None\n        self.y_score=None\n        self.num_it_epoch=num_it_epoch\n        self.num_it_total=num_it_total\n        self.evaluation=evaluation\n\n        self.train_sampler=train_sampler\n        self.train_batch_sampler=train_batch_sampler\n\n        self.labeled_sampler=labeled_sampler\n        self.unlabeled_sampler=unlabeled_sampler\n        self.labeled_batch_sampler=labeled_batch_sampler\n        self.unlabeled_batch_sampler = unlabeled_batch_sampler\n\n        self.valid_sampler=valid_sampler if valid_sampler is not None else test_sampler\n        self.valid_batch_sampler=valid_batch_sampler if valid_batch_sampler is not None else test_batch_sampler\n\n        self.test_sampler=test_sampler\n        self.test_batch_sampler=test_batch_sampler\n\n        self.valid_performance=None\n\n        self.parallel=parallel\n        self.verbose=verbose\n        self.it_epoch=0\n        self.it_total=0\n        self.loss=None\n        self.weak_augmentation=None\n        self.strong_augmentation=None\n        self.normalization=None\n        self.performance=None\n        self.valid_performance=None\n        self.ema=None\n        if isinstance(file,str):\n            file=open(file,\"w\")\n        self.file=file\n        self._estimator_type=None\n\n    def init_model(self):\n        self._network = copy.deepcopy(self.network)\n        self._parallel = copy.deepcopy(self.parallel)\n        if self.device is None:\n            self.device='cpu'\n        if self.device is not 'cpu':\n            torch.cuda.set_device(self.device)\n        self._network=self._network.to(self.device)\n        if self._parallel is not None:\n            self._network=self._parallel.init_parallel(self._network)\n\n    def init_ema(self):\n        if self.ema_decay is not None:\n            self.ema=EMA(model=self._network,decay=self.ema_decay)\n            self.ema.register()\n        else:\n            self.ema=None\n\n    def init_optimizer(self):\n        self._optimizer=copy.deepcopy(self.optimizer)\n        if isinstance(self._optimizer,BaseOptimizer):\n            no_decay = ['bias', 'bn']\n            grouped_parameters = [\n                {'params': [p for n, p in self._network.named_parameters() if not any(\n                    nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\n                {'params': [p for n, p in self._network.named_parameters() if any(\n                    nd in n for nd in no_decay)], 'weight_decay': 0.0}\n            ]\n            self._optimizer=self._optimizer.init_optimizer(params=grouped_parameters)\n\n    def init_scheduler(self):\n        self._scheduler=copy.deepcopy(self.scheduler)\n        if isinstance(self._scheduler,BaseScheduler):\n            self._scheduler=self._scheduler.init_scheduler(optimizer=self._optimizer)\n\n    def init_epoch(self):\n        if self.num_it_epoch is not None and self.epoch is not None:\n            self.num_it_total=self.epoch*self.num_it_epoch\n        elif self.num_it_total is not None and self.epoch is not None:\n            self.num_it_epoch=ceil(self.num_it_total/self.epoch)\n        elif self.num_it_total is not None and self.num_it_epoch is not None:\n            self.epoch=ceil(self.num_it_total/self.num_it_epoch)\n\n    def init_augmentation(self):\n        self._augmentation = copy.deepcopy(self.augmentation)\n        if self._augmentation is not None:\n            if isinstance(self._augmentation, dict):\n                self.weak_augmentation = self._augmentation['augmentation'] \\\n                    if 'augmentation' in self._augmentation.keys() \\\n                    else self._augmentation['weak_augmentation']\n                if 'strong_augmentation' in self._augmentation.keys():\n                    self.strong_augmentation = self._augmentation['strong_augmentation']\n            elif isinstance(self._augmentation, (list, tuple)):\n                self.weak_augmentation = self._augmentation[0]\n                if len(self._augmentation) > 1:\n                    self.strong_augmentation = self._augmentation[1]\n            else:\n                self.weak_augmentation = copy.copy(self._augmentation)\n            if self.strong_augmentation is None:\n                self.strong_augmentation = copy.copy(self.weak_augmentation)\n\n    def init_transform(self):\n        if self.weak_augmentation is not None:\n            self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n            self._train_dataset.add_unlabeled_transform(self.weak_augmentation, dim=1, x=0, y=0)\n\n    def init_train_dataset(self,X=None,y=None,unlabeled_X=None, *args, **kwargs):\n        self._train_dataset=copy.deepcopy(self.train_dataset)\n        if isinstance(X,TrainDataset):\n            self._train_dataset=X\n        elif isinstance(X,Dataset) and y is None:\n            self._train_dataset.init_dataset(labeled_dataset=X, unlabeled_dataset=unlabeled_X)\n        else:\n            self._train_dataset.init_dataset(labeled_X=X, labeled_y=y,unlabeled_X=unlabeled_X)\n\n    def init_train_dataloader(self):\n        self._train_dataloader=copy.deepcopy(self.train_dataloader)\n        self._labeled_dataloader = copy.deepcopy(self.labeled_dataloader)\n        self._unlabeled_dataloader = copy.deepcopy(self.unlabeled_dataloader)\n        self._train_sampler=copy.deepcopy(self.train_sampler)\n        self._labeled_sampler = copy.deepcopy(self.labeled_sampler)\n        self._unlabeled_sampler = copy.deepcopy(self.unlabeled_sampler)\n        self._train_batch_sampler=copy.deepcopy(self.train_batch_sampler)\n        self._labeled_batch_sampler = copy.deepcopy(self.labeled_batch_sampler)\n        self._unlabeled_batch_sampler = copy.deepcopy(self.unlabeled_batch_sampler)\n        if self._train_dataloader is not None:\n            self._labeled_dataloader,self._unlabeled_dataloader=self._train_dataloader.init_dataloader(dataset=self._train_dataset,\n                                                                                       sampler=self._train_sampler,\n                                                                                       batch_sampler=self._train_batch_sampler,\n                                                                                       mu=self.mu)\n        else:\n            self._train_dataloader=TrainDataLoader(labeled_dataloader=self._labeled_dataloader,unlabeled_dataloader=self._unlabeled_dataloader)\n            self._train_sampler={'labeled':self._labeled_sampler,'unlabeled':self._unlabeled_sampler}\n            self._train_batch_sampler={'labeled':self._labeled_batch_sampler,'unlabeled':self._unlabeled_batch_sampler}\n            self._labeled_dataloader, self._unlabeled_dataloader = self._train_dataloader.init_dataloader(\n                dataset=self._train_dataset,\n                sampler=self._train_sampler,\n                batch_sampler=self._train_batch_sampler,\n                mu=self.mu)\n\n    def start_fit(self, *args, **kwargs):\n        self.init_epoch()\n        self._network.zero_grad()\n        self._network.train()\n\n    def start_fit_epoch(self, *args, **kwargs):\n        pass\n\n    def start_fit_batch(self, *args, **kwargs):\n        pass\n\n    def train(self,lb_X=None,lb_y=None,ulb_X=None,lb_idx=None,ulb_idx=None,*args,**kwargs):\n        raise NotImplementedError\n\n    def get_loss(self,train_result,*args,**kwargs):\n        raise NotImplementedError\n\n    def optimize(self,loss,*args,**kwargs):\n        self._network.zero_grad()\n        loss.backward()\n        self._optimizer.step()\n        if self._scheduler is not None:\n            self._scheduler.step()\n        if self.ema is not None:\n            self.ema.update()\n\n    def end_fit_batch(self, train_result,*args, **kwargs):\n        self.loss = self.get_loss(train_result)\n        self.optimize(self.loss)\n\n    def fit_batch_loop(self,valid_X=None,valid_y=None):\n        for (lb_idx, lb_X, lb_y), (ulb_idx, ulb_X, _) in zip(self._labeled_dataloader, self._unlabeled_dataloader):\n            if self.it_epoch >= self.num_it_epoch or self.it_total >= self.num_it_total:\n                break\n            self.start_fit_batch()\n            lb_idx = to_device(lb_idx,self.device)\n            lb_X = to_device(lb_X,self.device)\n            lb_y = to_device(lb_y,self.device)\n            ulb_idx = to_device(ulb_idx,self.device)\n            ulb_X  = to_device(ulb_X,self.device)\n            train_result = self.train(lb_X=lb_X, lb_y=lb_y, ulb_X=ulb_X, lb_idx=lb_idx, ulb_idx=ulb_idx)\n            self.end_fit_batch(train_result)\n            self.it_total += 1\n            self.it_epoch += 1\n            if self.verbose:\n                print(self.it_total,file=self.file)\n                print(self.it_total)\n            if valid_X is not None and self.eval_it is not None and self.it_total % self.eval_it == 0:\n                self.evaluate(X=valid_X, y=valid_y,valid=True)\n                self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n\n    def end_fit_epoch(self, *args, **kwargs):\n        pass\n\n    def fit_epoch_loop(self,valid_X=None,valid_y=None):\n        self.valid_performance={}\n        self.it_total = 0\n        for self._epoch in range(1,self.epoch+1):\n            self.it_epoch=0\n            if self.it_total >= self.num_it_total:\n                break\n            self.start_fit_epoch()\n            self.fit_batch_loop(valid_X,valid_y)\n            self.end_fit_epoch()\n            if valid_X is not None and self.eval_epoch is not None and self._epoch % self.eval_epoch==0:\n                self.evaluate(X=valid_X,y=valid_y,valid=True)\n                self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n\n        if valid_X is not None and (self.eval_epoch is None or self.epoch% self.eval_epoch!=0):\n            self.evaluate(X=valid_X, y=valid_y, valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n\n    def end_fit(self, *args, **kwargs):\n        pass\n\n    def fit(self,X=None,y=None,unlabeled_X=None,valid_X=None,valid_y=None):\n        self.init_train_dataset(X,y,unlabeled_X)\n        self.init_train_dataloader()\n        if self.network is not None:\n            self.init_model()\n            self.init_ema()\n            self.init_optimizer()\n            self.init_scheduler()\n        self.init_augmentation()\n        self.init_transform()\n        self.start_fit()\n        self.fit_epoch_loop(valid_X,valid_y)\n        self.end_fit()\n        return self\n\n    def init_estimate_dataset(self, X=None,valid=False):\n        self._valid_dataset = copy.deepcopy(self.valid_dataset)\n        self._test_dataset=copy.deepcopy(self.test_dataset)\n        if valid:\n            if isinstance(X,Dataset):\n                self._valid_dataset=X\n            else:\n                self._valid_dataset=self._valid_dataset.init_dataset(X=X)\n        else:\n            if isinstance(X,Dataset):\n                self._test_dataset=X\n            else:\n                self._test_dataset=self._test_dataset.init_dataset(X=X)\n\n    def init_estimate_dataloader(self,valid=False):\n        self._valid_dataloader=copy.deepcopy(self.valid_dataloader)\n        self._test_dataloader = copy.deepcopy(self.test_dataloader)\n        self._valid_sampler = copy.deepcopy(self.valid_sampler)\n        self._test_sampler=copy.deepcopy(self.test_sampler)\n        self._valid_batch_sampler=copy.deepcopy(self.valid_batch_sampler)\n        self._test_batch_sampler=copy.deepcopy(self.test_batch_sampler)\n        if valid:\n            self._estimate_dataloader=self._valid_dataloader.init_dataloader(self._valid_dataset,\n                                                            sampler=self._valid_sampler,\n                                                            batch_sampler=self._valid_batch_sampler)\n        else:\n            self._estimate_dataloader=self._test_dataloader.init_dataloader(self._test_dataset,\n                                                            sampler=self._test_sampler,\n                                                            batch_sampler=self._test_batch_sampler)\n\n    def start_predict(self, *args, **kwargs):\n        self._network.eval()\n        if self.ema is not None:\n            self.ema.apply_shadow()\n        self.y_est = torch.Tensor().to(self.device)\n\n    def start_predict_batch(self, *args, **kwargs):\n        pass\n\n    @torch.no_grad()\n    def estimate(self, X, idx=None, *args, **kwargs):\n        outputs = self._network(X)\n        return outputs\n\n    def end_predict_batch(self, *args, **kwargs):\n        pass\n\n    def predict_batch_loop(self):\n        with torch.no_grad():\n            for idx,X,_ in self._estimate_dataloader:\n                self.start_predict_batch()\n                idx=to_device(idx,self.device)\n                X=X[0] if isinstance(X,(list,tuple)) else X\n                X=to_device(X,self.device)\n                _est = self.estimate(X=X,idx=idx)\n                _est = _est[0] if  isinstance(_est,(list,tuple)) else _est\n                self.y_est=torch.cat((self.y_est,_est),0)\n                self.end_predict_batch()\n\n    @torch.no_grad()\n    def get_predict_result(self, y_est, *args, **kwargs):\n        if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n            y_score = Softmax(dim=-1)(y_est)\n            max_probs, y_pred = torch.max(y_score, dim=-1)\n            y_pred = y_pred.cpu().detach().numpy()\n            self.y_score = y_score.cpu().detach().numpy()\n            return y_pred\n        else:\n            self.y_score = y_est.cpu().detach().numpy()\n            y_pred = self.y_score\n            return y_pred\n\n    def end_predict(self, *args, **kwargs):\n        self.y_pred = self.get_predict_result(self.y_est)\n        if self.ema is not None:\n            self.ema.restore()\n        self._network.train()\n\n    @torch.no_grad()\n    def predict(self,X=None,valid=False):\n        self.init_estimate_dataset(X,valid)\n        self.init_estimate_dataloader(valid)\n        self.start_predict()\n        self.predict_batch_loop()\n        self.end_predict()\n        return self.y_pred\n\n    @torch.no_grad()\n    def predict_proba(self,X=None,valid=False):\n        self.init_estimate_dataset(X,valid)\n        self.init_estimate_dataloader(valid)\n        self.start_predict()\n        self.predict_batch_loop()\n        self.end_predict()\n        return self.y_score\n\n    @torch.no_grad()\n    def evaluate(self,X,y=None,valid=False):\n\n        if isinstance(X,Dataset) and y is None:\n            y=getattr(X,'y')\n\n        self.y_pred=self.predict(X,valid=valid)\n        self.y_score=self.y_score\n\n        if self.evaluation is None:\n            return None\n        elif isinstance(self.evaluation,(list,tuple)):\n            performance=[]\n            for eval in self.evaluation:\n                if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                    score=eval.scoring(y,self.y_pred,self.y_score)\n                else:\n                    score = eval.scoring(y,self.y_pred)\n                performance.append(score)\n                if self.verbose:\n                    print(score, file=self.file)\n                    print(score)\n            self.performance = performance\n            return performance\n        elif isinstance(self.evaluation,dict):\n            performance={}\n            for key,val in self.evaluation.items():\n                if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                    performance[key]=val.scoring(y,self.y_pred,self.y_score)\n                else:\n                    performance[key] = val.scoring(y, self.y_pred)\n                if self.verbose:\n                    print(key,' ',performance[key],file=self.file)\n                    print(key, ' ', performance[key])\n                self.performance = performance\n            return performance\n        else:\n            if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n            else:\n                performance = self.evaluation.scoring(y, self.y_pred)\n            if self.verbose:\n                print(performance, file=self.file)\n                print(performance)\n            self.performance=performance\n            return performance"
  },
  {
    "path": "LAMDA_SSL/Base/GraphMixin.py",
    "content": "from LAMDA_SSL.Transform.Graph.NormalizeFeatures import NormalizeFeatures\nfrom sklearn.pipeline import Pipeline\n\nclass GraphMixin:\n    def __init__(self):\n        pass\n\n    def init_default_transforms(self):\n        # >> init_default_transform: Initialize the data transformation method.\n        self.transforms=None\n        self.target_transform=None\n        self.transform=Pipeline([('NormalizeFeatures',NormalizeFeatures())\n                              ])\n        self.unlabeled_transform=Pipeline([('NormalizeFeatures',NormalizeFeatures())\n                              ])\n        self.test_transform=Pipeline([('NormalizeFeatures',NormalizeFeatures())\n                              ])\n        self.valid_transform=Pipeline([('NormalizeFeatures',NormalizeFeatures())\n                              ])\n        return self"
  },
  {
    "path": "LAMDA_SSL/Base/InductiveEstimator.py",
    "content": "from .SemiEstimator import SemiEstimator\nfrom abc import abstractmethod\n\nclass InductiveEstimator(SemiEstimator):\n    __semi_type__='Inductive'\n    @abstractmethod\n    def predict(self,X):\n    # >> predict(X): Make predictions on the new data.\n    # >> - X: Samples to be predicted.\n        raise NotImplementedError(\n            \"Predict method must be implemented.\"\n        )"
  },
  {
    "path": "LAMDA_SSL/Base/LambdaLR.py",
    "content": "from torch.optim import lr_scheduler\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\nclass LambdaLR(BaseScheduler):\n    def __init__(self,  lr_lambda, last_epoch=-1,verbose=False):\n        # >> Parameter:\n        # >> - lr_lambda: A function which computes a multiplicative factor given an integer parameter epoch, or a list of such functions, one for each group in optimizer.param_groups.\n        # >> - last_epoch: The index of last epoch.\n        # >> - verbose: If 'True', prints a message to stdout for each update.\n        super().__init__(last_epoch=last_epoch,verbose=verbose)\n        self.lr_lambda = lr_lambda\n        self.verbose=verbose\n\n    def init_scheduler(self,optimizer):\n        return lr_scheduler.LambdaLR(optimizer=optimizer,lr_lambda=self.lr_lambda,last_epoch=self.last_epoch,verbose=self.verbose)\n"
  },
  {
    "path": "LAMDA_SSL/Base/RegressorEvaluation.py",
    "content": "from abc import ABC,abstractmethod\n\nclass RegressorEvaluation(ABC):\n    def __init__(self):\n        pass\n    @abstractmethod\n    def scoring(self,y_true,y_pred=None):\n        # > scoring(y_true,y_pred=None): Score the performace of the model.\n        # >> - y_true: Ground-truth labels.\n        # >> - y_pred: The results of model's predictions.\n        raise NotImplementedError"
  },
  {
    "path": "LAMDA_SSL/Base/SemiEstimator.py",
    "content": "from sklearn.base import BaseEstimator\nfrom abc import ABC,abstractmethod\nclass SemiEstimator(ABC,BaseEstimator):\n    @abstractmethod\n    def fit(self,X,y,unlabeled_X):\n    # >> fit(X,y,unlabeled_X): Train a SSL model.\n    # >> - X: Instances of labeled data.\n    # >> - y: Labels of labeled data.\n    # >> - unlabeled_X: Instances of unlabeled data.\n        raise NotImplementedError(\n            \"The fit() method of SemiEstimator must be implemented.\"\n        )"
  },
  {
    "path": "LAMDA_SSL/Base/TabularMixin.py",
    "content": "from sklearn.pipeline import Pipeline\nfrom sklearn import preprocessing\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\n\nclass TabularMixin:\n    def __init__(self):\n        pass\n\n    def init_default_transforms(self):\n        # >> init_default_transform: Initialize the default data transformation method.\n        self.transforms=None\n        self.target_transform=None\n        self.pre_transform=Pipeline([('StandardScaler',preprocessing.StandardScaler())\n                              ])\n        self.transform=Pipeline([('ToTensor', ToTensor())])\n        self.unlabeled_transform=Pipeline([('ToTensor', ToTensor())])\n        self.test_transform=Pipeline([('ToTensor', ToTensor())])\n        self.valid_transform=Pipeline([('ToTensor', ToTensor())])\n        return self"
  },
  {
    "path": "LAMDA_SSL/Base/TextMixin.py",
    "content": "import copy\nfrom LAMDA_SSL.Transform.Text.Vocab import Vocab\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\nfrom LAMDA_SSL.Transform.Text.AdjustLength import AdjustLength\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nclass TextMixin:\n    def __init__(self,word_vocab=None,vectors=None,length=300,unk_token='<unk>',pad_token='<pad>',\n                 min_freq=1,special_first=True,default_index=None):\n        # >> parameter:\n        # >> - word_vocab: A map that converts words to indexes.\n        # >> - vectors: Word vectors.\n        # >> - length: Length of each sentence.\n        # >> - unk_token: The token used to represent unknown words.\n        # >> - pad_token: The token used to represent padding.\n        # >> - min_freq: The minimum frequency required for a word to be used as a token in the word_vocab. It is valid when word_vocab is None and a mapping table needs to be constructed.\n        # >> - special_first: Whether to put special characters at the top of the mapping table.\n        # >> - default_index: The default value that should be used when converting a word to an index if it cannot be converted.\n        # >> init_default_transform: Initialize the data transformation method.\n        self.vectors=vectors\n        self.word_vocab=word_vocab\n        self.length=length\n        self.unk_token=unk_token\n        self.pad_token=pad_token\n        self.min_freq=min_freq\n        self.special_first=special_first\n        self.specials=[self.unk_token,self.pad_token]\n        self.default_index=default_index\n\n    def init_default_transforms(self):\n\n        if self.vectors is not None:\n            self.vocab=Vocab(vectors=self.vectors.vec)\n\n        else:\n            if hasattr(self,'X'):\n                text=copy.copy(self.X)\n            elif hasattr(self,'labeled_X'):\n                text=copy.copy(self.labeled_X)\n            else:\n                text=None\n\n            self.vocab=Vocab(text=text,word_vocab=self.word_vocab,\n                             min_freq=self.min_freq,\n                             special_first=self.special_first,\n                             specials=self.specials,\n                             default_index=self.default_index)\n\n        self.pre_transform = Tokenizer('basic_english')\n        self.transform = Pipeline([('Adjust_length', AdjustLength(length=self.length)),\n                                   ('Vocab', self.vocab),\n                                   ('ToTensor', ToTensor())\n                                   ])\n        self.valid_transform=Pipeline([('Adjust_length', AdjustLength(length=self.length)),\n                                   ('Vocab', self.vocab),\n                                   ('ToTensor', ToTensor())\n                                   ])\n        self.test_transform=Pipeline([('Adjust_length', AdjustLength(length=self.length)),\n                                   ('Vocab', self.vocab),\n                                   ('ToTensor', ToTensor())\n                                   ])\n        self.unlabeled_transform=Pipeline([('Adjust_length', AdjustLength(length=self.length)),\n                                   ('Vocab', self.vocab),\n                                   ('ToTensor', ToTensor())\n                                   ])\n        self.target_transfrom=None\n        self.transforms=None"
  },
  {
    "path": "LAMDA_SSL/Base/TransductiveEstimator.py",
    "content": "from .SemiEstimator import SemiEstimator\nfrom abc import abstractmethod\n\nclass TransductiveEstimator(SemiEstimator):\n    __semi_type__='Transductive'\n    @abstractmethod\n    def predict(self,X=None,Transductive=True):\n    # >> predict(X=None,Transductive=True): Output the result of transductive learning or make predictions on the new data.\n    # >> - X: The samples to be predicted. It is only valid when Transductive is False.\n    # >> - Transductive: Whether to use transductive learning mechanism to directly output the prediction result of unlabeled_X input during fit.\n        raise NotImplementedError(\n            \"Predict method must be implemented.\"\n        )"
  },
  {
    "path": "LAMDA_SSL/Base/Transformer.py",
    "content": "from abc import abstractmethod,ABC\nfrom sklearn.base import BaseEstimator, TransformerMixin\n\nclass Transformer(BaseEstimator,TransformerMixin,ABC):\n    def __init__(self):\n        pass\n\n    def fit(self,X,y=None,**fit_params):\n        # >> fit(X,y=None): Obtain the processing function through existing data.\n        # >> - X: Samples for learning the function of transformation.\n        # >> - y: Labels for learning the function of transformation.\n        return self\n\n    def __call__(self, X,y=None,**fit_params):\n        # >> __call__(X,y=None): It is the same as fit_transform.\n        # >> - X: Samples for learning and transformation.\n        # >> - y: labels for learning.\n        return self.fit_transform(X,y,fit_params=fit_params)\n\n    @abstractmethod\n    def transform(self,X):\n        # >> transform(X): Process the new data.\n        # >> - X: Data to be converted.\n        raise NotImplementedError('Transform method of Augmentation class must be implemented.')\n\n    def fit_transform(self,X,y=None,**fit_params):\n        # >> fit_transform(X,y=None): Firstly perform fit() on the existing samples X and labels y, and then directly transform y.\n        # >> - X: Samples for learning and transformation.\n        # >> - y: Labels fo learning\n        return self.fit(X=X,y=y,fit_params=fit_params).transform(X)\n"
  },
  {
    "path": "LAMDA_SSL/Base/VisionMixin.py",
    "content": "from LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom sklearn.pipeline import Pipeline\nimport matplotlib.pyplot as plt\n\nclass VisionMixin:\n    def __init__(self,mean=None,std=None):\n        self.mean=mean\n        self.std=std\n        # >> Parameter\n        # >> - mean: Mean of the dataset.\n        # >> - std: Standard deviation of the dataset.\n    def init_default_transforms(self):\n        # >> init_default_transform: Initialize the default data transformation method.\n        self.transforms=None\n        self.target_transform=None\n        self.pre_transform=ToImage()\n        self.transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                              ('Normalization',Normalization(mean=self.mean,std=self.std))\n                              ])\n        self.unlabeled_transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                              ('Normalization',Normalization(mean=self.mean,std=self.std))\n                              ])\n        self.test_transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                              ('Normalization',Normalization(mean=self.mean,std=self.std))\n                              ])\n        self.valid_transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                              ('Normalization',Normalization(mean=self.mean,std=self.std))\n                              ])\n        return self\n\n\n    def show_image(self,img):\n        plt.imshow(img)\n        plt.axis('off')\n        plt.show()\n        return img"
  },
  {
    "path": "LAMDA_SSL/Base/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Config/Assemble.py",
    "content": "from sklearn.svm import SVC\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nbase_estimator=SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\nT=100\nalpha=1\nbeta=0.9\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/CAFA.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom LAMDA_SSL.Network.AdversarialNet import AdversarialNet\nfrom LAMDA_SSL.Scheduler.InverseDecaySheduler import InverseDecaySheduler\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=5e-4,momentum=0.9)\n\n# scheduler\n# scheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\nscheduler=InverseDecaySheduler(initial_lr=5e-4)\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=10\nwarmup=0.4\nmu=1\ndiscriminator = AdversarialNet(256)\ndiscriminator_separate = AdversarialNet(256)\ndiscriminator_optimizer=SGD(lr=1e-4, momentum=0.9)\ndiscriminator_optimizer_separate=SGD(lr=1e-4, momentum=0.9)\ndiscriminator_scheduler=InverseDecaySheduler(initial_lr=1e-4)\ndiscriminator_scheduler_separate=InverseDecaySheduler(initial_lr=1e-4)\neps=0.0014\n\nl_domain_temper = 1.\nu_domain_temper = 1.\nl_class_temper = 1.\nu_class_temper = 1.\nnum_classes=None\n\nthreshold=0.95\nT=0.5"
  },
  {
    "path": "LAMDA_SSL/Config/CoReg.py",
    "content": "from LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\n\nk1=3\nk2=3\np1=2\np2=5\nmax_iters=100\npool_size=100\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/Co_Training.py",
    "content": "from sklearn.svm import SVC\nrandom_state=None\nbase_estimator = SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\nbase_estimator_2 = SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\np = 25\nn = 25\nk = 50\ns = 80\nbinary=False\nthreshold=0.5\nevaluation = None\nverbose = False\nfile = None"
  },
  {
    "path": "LAMDA_SSL/Config/Constrained_Seed_k_means.py",
    "content": "from LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score import Davies_Bouldin_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score import Fowlkes_Mallows_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Jaccard_Score import Jaccard_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Silhouette_Score import Silhouette_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Rand_Score import Rand_Score\nk=3\ntolerance=1e-7\nmax_iterations=300\nevaluation={\n    'Fowlkes_Mallows_Score':Fowlkes_Mallows_Score(),\n    'Jaccard_Score':Jaccard_Score(average='macro'),\n    'Rand_Score':Rand_Score(),\n    'Davies_Bouldin_Score':Davies_Bouldin_Score(),\n    'Silhouette_Score':Silhouette_Score()\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/Constrained_k_means.py",
    "content": "from LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score import Davies_Bouldin_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score import Fowlkes_Mallows_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Jaccard_Score import Jaccard_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Silhouette_Score import Silhouette_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Rand_Score import Rand_Score\nk=3\ntolerance=1e-7\nmax_iterations=300\nevaluation={\n    'Fowlkes_Mallows_Score':Fowlkes_Mallows_Score(),\n    'Jaccard_Score':Jaccard_Score(average='macro'),\n    'Rand_Score':Rand_Score(),\n    'Davies_Bouldin_Score':Davies_Bouldin_Score(),\n    'Silhouette_Score':Silhouette_Score()\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/FixMatch.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nthreshold=0.95\nlambda_u=1\nT=0.5\nmu=7"
  },
  {
    "path": "LAMDA_SSL/Config/FlexMatch.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nthreshold=0.95\nlambda_u=1.0\nT=0.5\nnum_classes=None\nuse_hard_labels=True\nthreshold_warmup=True\nmu=7\nuse_DA=False\np_target=None"
  },
  {
    "path": "LAMDA_SSL/Config/GAT.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\n\ndim_in=None\ndim_hidden=16\nheads=8\ndropout=0\nnum_classes=None\nnormalize=True\nweight_decay=5e-4\nepoch=2000\neval_epoch=None\ndevice='cpu'\nnetwork=None\nparallel=None\noptimizer=Adam(lr=0.01)\nscheduler=None\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nfile=None,\nverbose=False"
  },
  {
    "path": "LAMDA_SSL/Config/GCN.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\n\ndim_in=None\ndim_hidden=16\nnum_classes=None\nnormalize=True\nweight_decay=5e-4\nepoch=2000\neval_epoch=None\ndevice='cpu'\nnetwork=None\nparallel=None\noptimizer=Adam(lr=0.01)\nscheduler=None\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nfile=None,\nverbose=False"
  },
  {
    "path": "LAMDA_SSL/Config/ICT.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nalpha=0.5\nlambda_u=100\nwarmup=1 / 64\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/ICTReg.py",
    "content": "from LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nfrom LAMDA_SSL.Augmentation.Tabular.Noise import Noise\n\n\ntransforms = None\ntarget_transform = None\npre_transform = None\ntransform = ToTensor()\nunlabeled_transform = ToTensor()\ntest_transform = ToTensor()\nvalid_transform = ToTensor()\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\naugmentation=Noise(noise_level=0.01)\n\n# optimizer\noptimizer=SGD(lr=0.001,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=4000)\n\n# network\nnetwork=None\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nalpha=0.5\ndim_in=None\nlambda_u=0.001\nwarmup=1 / 64\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/ImprovedGAN.py",
    "content": "import torch.nn as nn\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\n\ntransforms = None\ntarget_transform = None\npre_transform = ToImage(channels=1,channels_first=False)\ntransform = ToTensor(dtype='float',image=True)\nunlabeled_transform = ToTensor(dtype='float',image=True)\ntest_transform = ToTensor(dtype='float',image=True)\nvalid_transform = ToTensor(dtype='float',image=True)\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=100*540)\nunlabeled_sampler=RandomSampler(replacement=False)\ntest_sampler=SequentialSampler()\nvalid_sampler=SequentialSampler()\n\n# optimizer\noptimizer=Adam(lr=0.02)\n\n# scheduler\nscheduler=None\n\n# network\nnetwork=None\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nweight_decay=0\nema_decay=None\n\nepoch=500\nnum_it_epoch=540\nnum_it_total=540*500\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=1\ndim_in=None\nnum_classes=None\nnum_labeled=None\ndim_z=100\nhidden_G=[500,500]\nhidden_D=[1000,500,250,250,250]\nnoise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5]\nactivations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus()]\nactivations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()]\nmu=1\n\n"
  },
  {
    "path": "LAMDA_SSL/Config/LabelPropagation.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nkernel = \"rbf\"\ngamma = 1\nn_neighbors = 7\nmax_iter = 10000\ntol = 1e-3\nn_jobs = None\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose = False\nfile = None"
  },
  {
    "path": "LAMDA_SSL/Config/LabelSpreading.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nkernel = \"rbf\"\ngamma = 1\nalpha=0.2\nn_neighbors = 7\nmax_iter = 10000\ntol = 1e-3\nn_jobs = None\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose = False\nfile = None"
  },
  {
    "path": "LAMDA_SSL/Config/LadderNetwork.py",
    "content": "import torch.nn as nn\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom LAMDA_SSL.Scheduler.LinearWarmup import LinearWarmup\n\ntransforms = None\ntarget_transform = None\npre_transform = ToImage(channels=1,channels_first=False)\ntransform = ToTensor(dtype='float',image=True)\nunlabeled_transform = ToTensor(dtype='float',image=True)\ntest_transform = ToTensor(dtype='float',image=True)\nvalid_transform = ToTensor(dtype='float',image=True)\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=100*540)\nunlabeled_sampler=RandomSampler(replacement=False)\ntest_sampler=SequentialSampler()\nvalid_sampler=SequentialSampler()\n\n# optimizer\noptimizer=Adam(lr=0.02)\n\n# scheduler\nscheduler=LinearWarmup(num_warmup_steps=15,num_training_steps=10,verbose=False)\n\n# network\nnetwork=None\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmu=1\nweight_decay=5e-4\nema_decay=None\nepoch=10\nnum_it_epoch=540\nnum_it_total=540*10\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\ndim_in=None\nnum_classes=None\nnoise_std=0.2\nlambda_u=[0.1, 0.1, 0.1, 0.1, 0.1, 10., 1000.]\ndim_encoder=[1000, 500, 250, 250, 250]\nencoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()]\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Config/LapSVM.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom sklearn.metrics.pairwise import rbf_kernel\n\n\nneighbor_mode=None\ndistance_function= rbf_kernel\ngamma_d=None\nt=1\nn_neighbor= 5\nkernel_function= rbf_kernel\ngamma_k=None\ngamma_A= 0.03\ngamma_I= 0\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/MeanTeacher.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=50\nwarmup=0.4\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/MeanTeacherReg.py",
    "content": "from LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nfrom LAMDA_SSL.Augmentation.Tabular.Noise import Noise\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\n\ntransforms = None\ntarget_transform = None\npre_transform = None\ntransform = ToTensor()\nunlabeled_transform = ToTensor()\ntest_transform = ToTensor()\nvalid_transform = ToTensor()\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# augmentation\naugmentation=Noise(noise_level=0.01)\n\n# optimizer\noptimizer=SGD(lr=0.001,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=4000)\n\n# network\nnetwork=None\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\ndim_in=None\nlambda_u=0.001\nwarmup=0.4\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/MixMatch.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nalpha=0.5\nlambda_u=100\nnum_classes=None\nT=0.5\nwarmup=1 / 64\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/PiModel.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=10\nwarmup=0.4\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/PiModelReg.py",
    "content": "from LAMDA_SSL.Augmentation.Tabular.Noise import Noise\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error import Mean_Absolute_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error import Mean_Squared_Log_Error\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\ntransforms = None\ntarget_transform = None\npre_transform = None\ntransform = ToTensor()\nunlabeled_transform = ToTensor()\ntest_transform = ToTensor()\nvalid_transform = ToTensor()\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\naugmentation=Noise(noise_level=0.01)\n\n# optimizer\noptimizer=SGD(lr=0.001,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=4000)\n\n# network\nnetwork=None\n\nevaluation={\n    'Mean_Absolute_Error':Mean_Absolute_Error(),\n    'Mean_Squared_Error':Mean_Squared_Error(),\n    'Mean_Squared_Log_Error':Mean_Squared_Log_Error()\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\ndim_in=None\nlambda_u=0.001\nwarmup=0.4\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/PseudoLabel.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nthreshold=0.95\nlambda_u=1\nwarmup=0.4\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/ReMixMatch.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nalpha=0.5\nlambda_u=1.5\nlambda_s=0.5\nlambda_rot=0.5\nT=0.5\nwarmup=0.015625\nnum_classes=None\nrotate_v_list=[0, 90, 180, 270]\np_target = None\nmu=1\n"
  },
  {
    "path": "LAMDA_SSL/Config/S4L.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=(10,4),depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=1.5\nnum_classes=None\nlabeled_usp = True\nall_rot = True\nrotate_v_list=[0, 90, 180, 270]\np_target = None\nmu=1\n"
  },
  {
    "path": "LAMDA_SSL/Config/SDNE.py",
    "content": "from sklearn.linear_model import LogisticRegression\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Scheduler.StepLR import StepLR\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\n\nepoch = 1000\neval_epoch = None\noptimizer = Adam(lr=0.001)\nscheduler = StepLR(step_size=10, gamma=0.9, verbose=False)\ndevice = 'cpu'\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nweight_decay = 0\nnetwork = None\nparallel = None\nfile = None\nverbose = False\nxeqs = True\ndim_in = None\nnum_nodes = None\nhidden_layers = [1000,1000]\nalpha = 1e-3\nbeta = 10\ngamma = 1e-5\nbase_estimator = LogisticRegression()"
  },
  {
    "path": "LAMDA_SSL/Config/SSGMM.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\ntolerance=1e-5\nmax_iterations=300\nnum_classes=None\nrandom_state=None\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/SSVAE.py",
    "content": "import torch.nn as nn\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\n\ntransforms = None\ntarget_transform = None\npre_transform = ToImage(channels=1,channels_first=False)\ntransform = ToTensor(dtype='float',image=True)\nunlabeled_transform = ToTensor(dtype='float',image=True)\ntest_transform = ToTensor(dtype='float',image=True)\nvalid_transform = ToTensor(dtype='float',image=True)\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=100*540)\nunlabeled_sampler=RandomSampler(replacement=False)\ntest_sampler=SequentialSampler()\nvalid_sampler=SequentialSampler()\n\n# optimizer\noptimizer=Adam(lr=0.02)\n\n# scheduler\nscheduler=None\n\n# network\nnetwork=None\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\nmu=1\nweight_decay=0\nema_decay=None\n\nepoch=500\nnum_it_epoch=540\nnum_it_total=540*500\neval_it=None\neval_epoch=None\n\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nalpha=5\nnum_labeled=None\ndim_in=None\nnum_classes=None\ndim_z=100\ndim_hidden_de=[500, 500]\ndim_hidden_en_y=[500, 500]\ndim_hidden_en_z=[500, 500]\nactivations_de=[nn.Softplus(), nn.Softplus()]\nactivations_en_y=[nn.Softplus(), nn.Softplus()]\nactivations_en_z=[nn.Softplus(), nn.Softplus()]\n\n"
  },
  {
    "path": "LAMDA_SSL/Config/SemiBoost.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom sklearn.svm import SVC\n\nbase_estimator = SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\nn_neighbors=4\nn_jobs = 1\nT = 300\nsample_percent = 0.01\nsigma_percentile = 90\nsimilarity_kernel = 'rbf'\ngamma=None\n\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/TSVM.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nCl = 15\nCu = 0.0001\nkernel = 'rbf'\ndegree = 3\ngamma = \"scale\"\ncoef0 = 0.0\nshrinking = True\nprobability = True\ntol = 1e-3\ncache_size = 200\nclass_weight = None\nmax_iter = -1\ndecision_function_shape = \"ovr\"\nbreak_ties = False\nrandom_state = None\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose = False\nfile = None"
  },
  {
    "path": "LAMDA_SSL/Config/TemporalEnsembling.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=460*100)\nunlabeled_sampler=RandomSampler(replacement=False)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=100,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=100,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0.0001,T_max=400)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                        ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                      ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=400\nnum_it_epoch=460\nnum_it_total=400*460\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=30\nema_weight=0.6\nwarmup=0.4\nmu=1\nnum_classes = None\nnum_samples = None"
  },
  {
    "path": "LAMDA_SSL/Config/Tri_Training.py",
    "content": "from LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom sklearn.svm import SVC\nbase_estimator=SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\nbase_estimator_2=SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\nbase_estimator_3=SVC(C=1.0,kernel='rbf',probability=True,gamma='auto')\nevaluation={\n    'accuracy':Accuracy(),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\nverbose=False\nfile=None"
  },
  {
    "path": "LAMDA_SSL/Config/UDA.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\n\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nthreshold=0.8\nlambda_u=1.0\nT=0.4\nmu=7\ntsa_schedule=None\nnum_classes=None"
  },
  {
    "path": "LAMDA_SSL/Config/VAT.py",
    "content": "from LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\nmean = [0.4914, 0.4822, 0.4465]\nstd = [0.2471, 0.2435, 0.2616]\n\npre_transform = ToImage()\ntransforms = None\ntarget_transform = None\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                    ('Normalization', Normalization(mean=mean, std=std))\n                    ])\nunlabeled_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\ntest_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                ('Normalization', Normalization(mean=mean, std=std))\n                                ])\nvalid_transform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                                 ('Normalization', Normalization(mean=mean, std=std))\n                                 ])\ntrain_dataset=None\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\n\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\n\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\n\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\n# Batch sampler\ntrain_batch_sampler=None\nlabeled_batch_sampler=None\nunlabeled_batch_sampler=None\nvalid_batch_sampler=None\ntest_batch_sampler=None\n\n# sampler\ntrain_sampler=None\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n\n#dataloader\ntrain_dataloader=None\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n\n# network\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n\n# optimizer\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n\n# scheduler\nscheduler=CosineAnnealingLR(eta_min=0,T_max=2**20)\n\n# augmentation\naugmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\n# evalutation\nevaluation={\n    'accuracy':Accuracy(),\n    'top_5_accuracy':Top_k_Accurary(k=5),\n    'precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_Matrix(normalize='true')\n}\n\n# model\nweight_decay=5e-4\nema_decay=0.999\nepoch=1\nnum_it_total=2**20\nnum_it_epoch=2**20\neval_epoch=None\neval_it=None\ndevice='cpu'\n\nparallel=None\nfile=None\nverbose=False\n\nlambda_u=0.3\nlambda_entmin=0.06\neps=6\nxi=1e-6\nit_vat=1\nwarmup=0.4\nmu=1"
  },
  {
    "path": "LAMDA_SSL/Config/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Dataloader/LabeledDataloader.py",
    "content": "from torch.utils.data.dataloader import DataLoader\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom LAMDA_SSL.Sampler.BatchSampler import BatchSampler\nclass LabeledDataLoader:\n    def __init__(self,\n                 batch_size= 1, shuffle: bool = False,\n                 sampler = None, batch_sampler= None,\n                 num_workers: int = 0, collate_fn= None,\n                 pin_memory: bool = False, drop_last: bool = False,\n                 timeout: float = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor: int = 2, persistent_workers: bool = False):\n        # >> Parameter\n        # >> - batch_size: How many samples per batch to load.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - sampler: The sampler used when loading data.\n        # >> - batch_sampler: set to True to have the data reshuffled at every epoch.\n        # >> - num_workers: How many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.\n        # >> - collate_fn: Merges a list of samples to form a mini-batch of Tensor(s).  Used when using batched loading from a map-style dataset.\n        # >> - pin_memory: If True, the data loader will copy Tensors into CUDA pinned memory before returning them.  If your data elements are a custom type, or your :attr:'collate_fn' returns a batch that is a custom type, see the example below.\n        # >> - drop_last: Whether to discard redundant data that is not enough for a batch.\n        # >> - timeout: If positive, the timeout value for collecting a batch from workers. Should always be non-negative.\n        # >> - worker_init_fn: If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading.\n        # >> - multiprocessing_context: The context of multiprocessing.\n        # >> - generator: If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers.\n        # >> - prefetch_factor: Number of samples loaded in advance by each worker. '2' means there will be a total of 2 * num_workers samples prefetched across all workers.\n        # >> - persistent_workers: If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers 'Dataset' instances alive.\n        self.batch_size=batch_size\n        self.shuffle=shuffle\n        self.sampler=sampler\n        self.batch_sampler=batch_sampler\n        self.num_workers=num_workers\n        self.collate_fn=collate_fn\n        self.pin_memory=pin_memory\n        self.drop_last=drop_last\n        self.timeout=timeout\n        self.worker_init_fn=worker_init_fn\n        self.multiprocessing_context=multiprocessing_context\n        self.generator=generator\n        self.prefetch_factor=prefetch_factor\n        self.persistent_workers=persistent_workers\n        self.dataset=None\n        self.dataloader=None\n\n    def init_dataloader(self,dataset=None,sampler=None,batch_sampler=None):\n        self.dataset=dataset\n        if sampler is not None:\n            self.sampler=sampler\n        if isinstance(self.sampler,BaseSampler):\n            self.sampler=self.sampler.init_sampler(self.dataset)\n\n        if batch_sampler is not None:\n            self.batch_sampler=batch_sampler\n        if isinstance(self.batch_sampler,BatchSampler):\n            self.batch_sampler=self.batch_sampler.init_sampler(self.sampler)\n\n        if self.batch_sampler is None and self.sampler is None:\n            self.dataloader= DataLoader(dataset=self.dataset,\n                                batch_size=self.batch_size,\n                                shuffle = self.shuffle,\n                                sampler = self.sampler,\n                                batch_sampler = self.batch_sampler,\n                                num_workers = self.num_workers,\n                                collate_fn = self.collate_fn,\n                                pin_memory = self.pin_memory,\n                                drop_last = self.drop_last,\n                                timeout = self.timeout,\n                                worker_init_fn = self.worker_init_fn,\n                                multiprocessing_context = self.multiprocessing_context,\n                                generator = self.generator,\n                                prefetch_factor = self.prefetch_factor,\n                                persistent_workers = self.persistent_workers)\n        elif self.batch_sampler is not None:\n            self.dataloader = DataLoader(dataset=self.dataset,\n                                         batch_sampler=self.batch_sampler,\n                                         num_workers=self.num_workers,\n                                         collate_fn=self.collate_fn,\n                                         pin_memory=self.pin_memory,\n                                         timeout=self.timeout,\n                                         worker_init_fn=self.worker_init_fn,\n                                         multiprocessing_context=self.multiprocessing_context,\n                                         generator=self.generator,\n                                         prefetch_factor=self.prefetch_factor,\n                                         persistent_workers=self.persistent_workers)\n        else:\n            self.dataloader= DataLoader(dataset=self.dataset,\n                                batch_size=self.batch_size,\n                                shuffle = False,\n                                sampler = self.sampler,\n                                num_workers = self.num_workers,\n                                collate_fn = self.collate_fn,\n                                pin_memory = self.pin_memory,\n                                drop_last = self.drop_last,\n                                timeout = self.timeout,\n                                worker_init_fn = self.worker_init_fn,\n                                multiprocessing_context = self.multiprocessing_context,\n                                generator = self.generator,\n                                prefetch_factor = self.prefetch_factor,\n                                persistent_workers = self.persistent_workers)\n        return self.dataloader\n"
  },
  {
    "path": "LAMDA_SSL/Dataloader/TrainDataloader.py",
    "content": "import copy\n\nfrom torch.utils.data.dataloader import DataLoader\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom LAMDA_SSL.Sampler.BatchSampler import BatchSampler\n\nclass TrainDataLoader:\n    def __init__(self,\n                 batch_size=1,\n                 shuffle = False, sampler = None,\n                 batch_sampler=None,\n                 num_workers = 0, collate_fn = None,\n                 pin_memory = False, drop_last = True,\n                 timeout = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor = 2,\n                 persistent_workers= False,\n                 batch_size_adjust=False,labeled_dataloader=None,unlabeled_dataloader=None):\n        # >> Parameter\n        # >> - batch_size: How many samples per batch to load.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - sampler: The sampler used when loading data.\n        # >> - batch_sampler: set to True to have the data reshuffled at every epoch.\n        # >> - num_workers: How many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.\n        # >> - collate_fn: Merges a list of samples to form a mini-batch of Tensor(s).  Used when using batched loading from a map-style dataset.\n        # >> - pin_memory: If True, the data loader will copy Tensors into CUDA pinned memory before returning them.  If your data elements are a custom type, or your :attr:'collate_fn' returns a batch that is a custom type, see the example below.\n        # >> - drop_last: Whether to discard redundant data that is not enough for a batch.\n        # >> - timeout: If positive, the timeout value for collecting a batch from workers. Should always be non-negative.\n        # >> - worker_init_fn: If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading.\n        # >> - multiprocessing_context: The context of multiprocessing.\n        # >> - generator: If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers.\n        # >> - prefetch_factor: Number of samples loaded in advance by each worker. '2' means there will be a total of 2 * num_workers samples prefetched across all workers.\n        # >> - persistent_workers: If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers 'Dataset' instances alive.\n        # >> - batch_size_adjust: Whether to automatically adjust the batch_size of labeled_dataloader and unlabeled_dataloader according to the ratio of unlabeled samples to labeled samples.\n        # >> - labeled_dataloader: The dataloader of labeled data.\n        # >> - unlabeled_dataloader: The dataloader of unlabeled data.\n        self.labeled_dataloader=labeled_dataloader\n        self.unlabeled_dataloader=unlabeled_dataloader\n        if self.labeled_dataloader is None and self.unlabeled_dataloader is None:\n            self.batch_size=batch_size\n            if isinstance(self.batch_size,(list,tuple)):\n                self.labeled_batch_size,self.unlabeled_batch_size=self.batch_size[0],self.batch_size[1]\n            elif isinstance(self.batch_size,dict):\n                self.labeled_batch_size, self.unlabeled_batch_size = self.batch_size['labeled'], self.batch_size['unlabeled']\n            else:\n                self.labeled_batch_size, self.unlabeled_batch_size=copy.copy(self.batch_size), copy.copy(self.batch_size)\n\n            self.shuffle=shuffle\n            if isinstance(self.shuffle,(list,tuple)):\n                self.labeled_shuffle,self.unlabeled_shuffle=self.shuffle[0],self.shuffle[1]\n            elif isinstance(self.shuffle,dict):\n                self.labeled_shuffle,self.unlabeled_shuffle = self.shuffle['labeled'], self.shuffle['unlabeled']\n            else:\n                self.labeled_shuffle,self.unlabeled_shuffle=copy.copy(self.shuffle),copy.copy( self.shuffle)\n\n            self.sampler=sampler\n            if isinstance(self.sampler,(list,tuple)):\n                self.labeled_sampler,self.unlabeled_sampler=self.sampler[0],self.sampler[1]\n            elif isinstance(self.sampler,dict):\n                self.labeled_sampler,self.unlabeled_sampler = self.sampler['labeled'], self.sampler['unlabeled']\n            else:\n                self.labeled_sampler,self.unlabeled_sampler=copy.copy(self.sampler), copy.copy(self.sampler)\n\n            self.batch_sampler=batch_sampler\n            if isinstance(self.batch_sampler,(list,tuple)):\n                self.labeled_batch_sampler,self.unlabeled_batch_sampler=self.batch_sampler[0],self.batch_sampler[1]\n            elif isinstance(self.batch_sampler,dict):\n                self.labeled_batch_sampler,self.unlabeled_batch_sampler = self.batch_sampler['labeled'], self.batch_sampler['unlabeled']\n            else:\n                self.labeled_batch_sampler,self.unlabeled_batch_sampler=copy.copy(self.batch_sampler), copy.copy(self.batch_sampler)\n\n            self.num_workers=num_workers\n            if isinstance(self.num_workers,(list,tuple)):\n                self.labeled_num_workers,self.unlabeled_num_workers=self.num_workers[0],self.num_workers[1]\n            elif isinstance(self.num_workers,dict):\n                self.labeled_num_workers,self.unlabeled_num_workers = self.num_workers['labeled'], self.num_workers['unlabeled']\n            else:\n                self.labeled_num_workers,self.unlabeled_num_workers=copy.copy(self.num_workers), copy.copy(self.num_workers)\n\n            self.collate_fn=collate_fn\n            if isinstance(self.collate_fn,(list,tuple)):\n                self.labeled_collate_fn,self.unlabeled_collate_fn=self.collate_fn[0],self.collate_fn[1]\n            elif isinstance(self.collate_fn,dict):\n                self.labeled_collate_fn,self.unlabeled_collate_fn= self.collate_fn['labeled'], self.collate_fn['unlabeled']\n            else:\n                self.labeled_collate_fn,self.unlabeled_collate_fn=copy.copy(self.collate_fn), copy.copy(self.collate_fn)\n\n            self.pin_memory=pin_memory\n            if isinstance(self.pin_memory,(list,tuple)):\n                self.labeled_pin_memory,self.unlabeled_pin_memory=self.pin_memory[0],self.pin_memory[1]\n            elif isinstance(self.pin_memory,dict):\n                self.labeled_pin_memory,self.unlabeled_pin_memory = self.pin_memory['labeled'], self.pin_memory['unlabeled']\n            else:\n                self.labeled_pin_memory,self.unlabeled_pin_memory=copy.copy(self.pin_memory), copy.copy(self.pin_memory)\n\n            self.drop_last=drop_last\n            if isinstance(self.drop_last,(list,tuple)):\n                self.labeled_drop_last,self.unlabeled_drop_last=self.drop_last[0],self.drop_last[1]\n            elif isinstance(self.drop_last,dict):\n                self.labeled_drop_last,self.unlabeled_drop_last = self.drop_last['labeled'], self.drop_last['unlabeled']\n            else:\n                self.labeled_drop_last,self.unlabeled_drop_last=copy.copy(self.drop_last), copy.copy(self.drop_last)\n\n            self.timeout=timeout\n            if isinstance(self.timeout,(list,tuple)):\n                self.labeled_timeout,self.unlabeled_timeout=self.timeout[0],self.timeout[1]\n            elif isinstance(self.timeout,dict):\n                self.labeled_timeout,self.unlabeled_timeout = self.timeout['labeled'], self.timeout['unlabeled']\n            else:\n                self.labeled_timeout,self.unlabeled_timeout=copy.copy(self.timeout), copy.copy(self.timeout)\n\n            self.worker_init_fn=worker_init_fn\n            if isinstance(self.worker_init_fn,(list,tuple)):\n                self.labeled_worker_init_fn,self.unlabeled_worker_init_fn=self.worker_init_fn[0],self.worker_init_fn[1]\n            elif isinstance(self.worker_init_fn,dict):\n                self.labeled_worker_init_fn,self.unlabeled_worker_init_fn = self.worker_init_fn['labeled'], self.worker_init_fn['unlabeled']\n            else:\n                self.labeled_worker_init_fn,self.unlabeled_worker_init_fn=copy.copy(self.worker_init_fn), copy.copy(self.worker_init_fn)\n\n            self.multiprocessing_context=multiprocessing_context\n            if isinstance(self.multiprocessing_context,(list,tuple)):\n                self.labeled_multiprocessing_context,self.unlabeled_multiprocessing_context=self.multiprocessing_context[0],self.multiprocessing_context[1]\n            elif isinstance(self.multiprocessing_context,dict):\n                self.labeled_multiprocessing_context,self.unlabeled_multiprocessing_context = self.multiprocessing_context['labeled'], self.multiprocessing_context['unlabeled']\n            else:\n                self.labeled_multiprocessing_context,self.unlabeled_multiprocessing_context=copy.copy(self.multiprocessing_context), copy.copy(self.multiprocessing_context)\n\n            self.generator=generator\n            if isinstance(self.generator,(list,tuple)):\n                self.labeled_generator,self.unlabeled_generator=self.generator[0],self.generator[1]\n            elif isinstance(self.generator,dict):\n                self.labeled_generator,self.unlabeled_generator = self.generator['labeled'], self.generator['unlabeled']\n            else:\n                self.labeled_generator,self.unlabeled_generator=copy.copy(self.generator), copy.copy(self.generator)\n\n            self.prefetch_factor=prefetch_factor\n            if isinstance(self.prefetch_factor,(list,tuple)):\n                self.labeled_prefetch_factor,self.unlabeled_prefetch_factor=self.prefetch_factor[0],self.prefetch_factor[1]\n            elif isinstance(self.prefetch_factor,dict):\n                self.labeled_prefetch_factor,self.unlabeled_prefetch_factor = self.prefetch_factor['labeled'], self.prefetch_factor['unlabeled']\n            else:\n                self.labeled_prefetch_factor,self.unlabeled_prefetch_factor=copy.copy(self.prefetch_factor), copy.copy(self.prefetch_factor)\n\n            self.persistent_workers=persistent_workers\n            if isinstance(self.persistent_workers,(list,tuple)):\n                self.labeled_persistent_workers,self.unlabeled_persistent_workers=self.persistent_workers[0],self.persistent_workers[1]\n            elif isinstance(self.persistent_workers,dict):\n                self.labeled_persistent_workers,self.unlabeled_persistent_workers = self.persistent_workers['labeled'], self.persistent_workers['unlabeled']\n            else:\n                self.labeled_persistent_workers,self.unlabeled_persistent_workers=copy.copy(self.persistent_workers), copy.copy(self.persistent_workers)\n        else:\n            self.labeled_batch_size, self.unlabeled_batch_size = self.labeled_dataloader.batch_size, self.unlabeled_dataloader.batch_size\n            self.batch_size=[self.labeled_batch_size, self.unlabeled_batch_size]\n\n            self.labeled_shuffle, self.unlabeled_shuffle = self.labeled_dataloader.shuffle, self.unlabeled_dataloader.shuffle\n            self.shuffle = [self.labeled_shuffle, self.unlabeled_shuffle ]\n\n            self.labeled_sampler, self.unlabeled_sampler = self.labeled_dataloader.sampler, self.unlabeled_dataloader.sampler\n            self.sampler = [self.labeled_sampler, self.unlabeled_sampler]\n\n            self.labeled_batch_sampler, self.unlabeled_batch_sampler = self.labeled_dataloader.batch_sampler, self.unlabeled_dataloader.batch_sampler\n            self.batch_sampler = [self.labeled_batch_sampler, self.unlabeled_batch_sampler]\n\n\n            self.labeled_num_workers, self.unlabeled_num_workers = self.labeled_dataloader.num_workers, self.unlabeled_dataloader.num_workers\n            self.num_workers = [self.labeled_num_workers, self.unlabeled_num_workers ]\n\n            self.labeled_collate_fn, self.unlabeled_collate_fn = self.labeled_dataloader.collate_fn, self.unlabeled_dataloader.collate_fn\n            self.collate_fn = [self.labeled_collate_fn, self.unlabeled_collate_fn ]\n\n            self.labeled_pin_memory, self.unlabeled_pin_memory = self.labeled_dataloader.pin_memory, self.unlabeled_dataloader.pin_memory\n            self.pin_memory = [self.labeled_pin_memory, self.unlabeled_pin_memory ]\n\n            self.labeled_drop_last, self.unlabeled_drop_last = self.labeled_dataloader.drop_last, self.unlabeled_dataloader.drop_last\n            self.drop_last= [self.labeled_drop_last, self.unlabeled_drop_last ]\n\n            self.labeled_timeout, self.unlabeled_timeout = self.labeled_dataloader.timeout, self.unlabeled_dataloader.timeout\n            self.timeout= [self.labeled_timeout, self.unlabeled_timeout]\n\n            self.labeled_worker_init_fn , self.unlabeled_worker_init_fn  = self.labeled_dataloader.worker_init_fn , self.unlabeled_dataloader.worker_init_fn\n            self.worker_init_fn = [self.labeled_worker_init_fn , self.unlabeled_worker_init_fn ]\n\n            self.labeled_multiprocessing_context , self.unlabeled_multiprocessing_context  = self.labeled_dataloader.multiprocessing_context , self.unlabeled_dataloader.multiprocessing_context\n            self.multiprocessing_context = [self.labeled_multiprocessing_context , self.unlabeled_multiprocessing_context ]\n\n            self.labeled_generator , self.unlabeled_generator  = self.labeled_dataloader.generator , self.unlabeled_dataloader.generator\n            self.generator = [self.labeled_generator , self.unlabeled_generator ]\n\n            self.labeled_prefetch_factor , self.unlabeled_prefetch_factor  = self.labeled_dataloader.prefetch_factor , self.unlabeled_dataloader.prefetch_factor\n            self.prefetch_factor = [self.labeled_prefetch_factor , self.unlabeled_prefetch_factor ]\n\n            self.labeled_persistent_workers , self.unlabeled_persistent_workers  = self.labeled_dataloader.persistent_workers , self.unlabeled_dataloader.persistent_workers\n            self.persistent_workers = [self.labeled_persistent_workers , self.unlabeled_persistent_workers ]\n\n        self.dataset=None\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.len_labeled=None\n        self.len_unlabeled=None\n        self.batch_size_adjust=batch_size_adjust\n\n    def init_dataloader(self,dataset=None,labeled_dataset=None,unlabeled_dataset=None,sampler=None,batch_sampler=None,mu=None):\n\n        if mu is not None and self.labeled_batch_size is not None:\n            self.mu=mu\n            self.unlabeled_batch_size=self.mu*self.labeled_batch_size\n\n        if dataset is not None:\n            self.labeled_dataset=dataset.labeled_dataset\n            self.unlabeled_dataset=dataset.unlabeled_dataset\n        elif labeled_dataset is not None and unlabeled_dataset is not None:\n            self.labeled_dataset=labeled_dataset\n            self.unlabeled_dataset=unlabeled_dataset\n        else:\n            raise ValueError('No dataset')\n\n        self.len_labeled=self.labeled_dataset.__len__()\n        self.len_unlabeled=self.unlabeled_dataset.__len__()\n\n        if self.batch_size_adjust:\n            if self.len_labeled < self.len_unlabeled:\n                self.unlabeled_batch_size=self.labeled_batch_size*(self.len_unlabeled//self.len_labeled)\n            else:\n                self.labeled_batch_size = self.unlabeled_batch_size * (self.len_labeled//self.len_unlabeled)\n            self.mu=self.len_labeled//self.len_unlabeled\n\n        if sampler is not None:\n            if isinstance(sampler,(list,tuple)):\n                self.labeled_sampler,self.unlabeled_sampler=sampler[0],sampler[1]\n            elif isinstance(sampler,dict):\n                self.labeled_sampler,self.unlabeled_sampler=sampler['labeled'],sampler['unlabeled']\n            else:\n                self.labeled_sampler, self.unlabeled_sampler=copy.copy(sampler),copy.copy(sampler)\n            if self.mu is not None:\n                if self.labeled_sampler is not None and self.unlabeled_sampler is not None and\\\n                        hasattr(self.labeled_sampler, 'num_samples') and hasattr(self.unlabeled_sampler, 'num_samples')  \\\n                        and self.labeled_sampler.num_samples is not None and self.unlabeled_sampler.replacement is True:\n                    self.unlabeled_sampler.num_samples = self.labeled_sampler.num_samples *self.mu\n\n        if batch_sampler is not None:\n            if isinstance(batch_sampler,(list,tuple)):\n                self.labeled_batch_sampler,self.unlabeled_batch_sampler=batch_sampler[0],batch_sampler[1]\n            elif isinstance(batch_sampler,dict):\n                self.labeled_batch_sampler,self.unlabeled_batch_sampler=batch_sampler['labeled'],batch_sampler['unlabeled']\n            else:\n                self.labeled_batch_sampler, self.unlabeled_batch_sampler=copy.copy(batch_sampler),copy.copy(batch_sampler)\n            if self.mu is not None:\n                if self.labeled_batch_sampler is not None and self.unlabeled_batch_sampler is not None and\\\n                        hasattr(self.labeled_batch_sampler, 'batch_size') and hasattr(self.unlabeled_batch_sampler, 'batch_size')\\\n                        and self.labeled_batch_sampler.batch_size is not None:\n                    self.unlabeled_batch_sampler.batch_size = self.labeled_batch_sampler.batch_size*self.mu\n\n        if isinstance(self.labeled_sampler,BaseSampler):\n            self.labeled_sampler=self.labeled_sampler.init_sampler(self.labeled_dataset)\n\n        if isinstance(self.labeled_batch_sampler,BatchSampler):\n            self.labeled_batch_sampler=self.labeled_batch_sampler.init_sampler(self.labeled_sampler)\n\n        if isinstance(self.unlabeled_sampler,BaseSampler):\n            self.unlabeled_sampler=self.unlabeled_sampler.init_sampler(self.unlabeled_dataset)\n\n        if isinstance(self.unlabeled_batch_sampler,BatchSampler):\n            self.unlabeled_batch_sampler=self.unlabeled_batch_sampler.init_sampler(self.unlabeled_sampler)\n\n        # if self.labeled_dataloader is not None and self.unlabeled_dataloader is not None:\n        #     self.labeled_dataloader.batch_size=self.labeled_batch_size\n        #     self.unlabeled_dataloader.batch_size=self.unlabeled_batch_size\n        #\n        #     if self.mu is not None:\n        #         if self.labeled_dataloader.sampler is not None and self.unlabeled_dataloader.sampler is not None\\\n        #                 and hasattr(self.labeled_dataloader.sampler,'num_samples')\\\n        #                 and hasattr(self.unlabeled_dataloader.sampler,'num_samples')\\\n        #                 and self.labeled_dataloader.sampler.num_samples is not None:\n        #             self.unlabeled_dataloader.sampler.num_samples = self.labeled_dataloader.sampler.num_samples*self.mu\n        #     if self.mu is not None:\n        #         if self.labeled_dataloader.batch_sampler is not None  \\\n        #                 and self.unlabeled_dataloader.batch_sampler is not None\\\n        #                 and hasattr(self.labeled_dataloader.batch_sampler,'batch_size')\\\n        #                 and hasattr(self.unlabeled_dataloader.batch_sampler,'batch_size')\\\n        #                 and self.labeled_dataloader.batch_sampler.batch_size is not None:\n        #             self.unlabeled_dataloader.batch_sampler.batch_size = self.labeled_dataloader.batch_sampler.batch_size*self.mu\n        #\n        #\n        #     return self.labeled_dataloader,self.unlabeled_dataloader\n\n\n        if self.labeled_batch_sampler is None and self.labeled_sampler is None:\n            if self.labeled_dataloader is None:\n                self.labeled_dataloader=DataLoader(dataset=self.labeled_dataset,\n                                    batch_size=self.labeled_batch_size,\n                                    shuffle = self.labeled_shuffle,\n                                    sampler = self.labeled_sampler,\n                                    batch_sampler = self.labeled_batch_sampler,\n                                    num_workers = self.labeled_num_workers,\n                                    collate_fn = self.labeled_collate_fn,\n                                    pin_memory = self.labeled_pin_memory,\n                                    drop_last = self.labeled_drop_last,\n                                    timeout = self.labeled_timeout,\n                                    worker_init_fn = self.labeled_worker_init_fn,\n                                    multiprocessing_context = self.labeled_multiprocessing_context,\n                                    generator = self.labeled_generator,\n                                    prefetch_factor = self.labeled_prefetch_factor,\n                                    persistent_workers = self.labeled_persistent_workers)\n            else:\n                self.labeled_dataloader.batch_size = self.labeled_batch_size\n                self.labeled_dataloader=self.labeled_dataloader.init_dataloader(dataset=self.labeled_dataset)\n\n\n        elif self.labeled_batch_sampler is not None:\n            if self.labeled_dataloader is None:\n                self.labeled_dataloader=DataLoader(dataset=self.labeled_dataset,\n                                    batch_sampler = self.labeled_batch_sampler,\n                                    num_workers = self.labeled_num_workers,\n                                    collate_fn = self.labeled_collate_fn,\n                                    pin_memory = self.labeled_pin_memory,\n                                    timeout = self.labeled_timeout,\n                                    worker_init_fn = self.labeled_worker_init_fn,\n                                    multiprocessing_context = self.labeled_multiprocessing_context,\n                                    generator = self.labeled_generator,\n                                    prefetch_factor = self.labeled_prefetch_factor,\n                                    persistent_workers = self.labeled_persistent_workers)\n            else:\n                self.labeled_dataloader=self.labeled_dataloader.init_dataloader(dataset=self.labeled_dataset,\n                                                                                batch_sampler=self.labeled_batch_sampler)\n\n        else:\n            if self.labeled_dataloader is None:\n                self.labeled_dataloader=DataLoader(dataset=self.labeled_dataset,\n                                    batch_size=self.labeled_batch_size,\n                                    shuffle = False,\n                                    sampler = self.labeled_sampler,\n                                    num_workers = self.labeled_num_workers,\n                                    collate_fn = self.labeled_collate_fn,\n                                    pin_memory = self.labeled_pin_memory,\n                                    drop_last = self.labeled_drop_last,\n                                    timeout = self.labeled_timeout,\n                                    worker_init_fn = self.labeled_worker_init_fn,\n                                    multiprocessing_context = self.labeled_multiprocessing_context,\n                                    generator = self.labeled_generator,\n                                    prefetch_factor = self.labeled_prefetch_factor,\n                                    persistent_workers = self.labeled_persistent_workers)\n            else:\n                self.labeled_dataloader.batch_size = self.labeled_batch_size\n                self.labeled_dataloader = self.labeled_dataloader.init_dataloader(dataset=self.labeled_dataset,\n                                                                                  sampler=self.labeled_sampler)\n\n\n        if self.unlabeled_batch_sampler is None and self.unlabeled_sampler is None:\n            if self.unlabeled_dataloader is None:\n                self.unlabeled_dataloader=DataLoader(dataset=self.unlabeled_dataset,\n                                    batch_size=self.unlabeled_batch_size,\n                                    shuffle = self.unlabeled_shuffle,\n                                    sampler = self.unlabeled_sampler,\n                                    batch_sampler = self.unlabeled_batch_sampler,\n                                    num_workers = self.unlabeled_num_workers,\n                                    collate_fn = self.unlabeled_collate_fn,\n                                    pin_memory = self.unlabeled_pin_memory,\n                                    drop_last = self.unlabeled_drop_last,\n                                    timeout = self.unlabeled_timeout,\n                                    worker_init_fn = self.unlabeled_worker_init_fn,\n                                    multiprocessing_context = self.unlabeled_multiprocessing_context,\n                                    generator = self.unlabeled_generator,\n                                    prefetch_factor = self.unlabeled_prefetch_factor,\n                                    persistent_workers = self.unlabeled_persistent_workers)\n            else:\n                self.unlabeled_dataloader.batch_size = self.unlabeled_batch_size\n                self.unlabeled_dataloader=self.unlabeled_dataloader.init_dataloader(dataset=self.unlabeled_dataset)\n\n\n        elif self.unlabeled_batch_sampler is not None:\n            if self.unlabeled_dataloader is None:\n                self.unlabeled_dataloader=DataLoader(dataset=self.unlabeled_dataset,\n                                    batch_sampler = self.unlabeled_batch_sampler,\n                                    num_workers = self.unlabeled_num_workers,\n                                    collate_fn = self.unlabeled_collate_fn,\n                                    pin_memory = self.unlabeled_pin_memory,\n                                    timeout = self.unlabeled_timeout,\n                                    worker_init_fn = self.unlabeled_worker_init_fn,\n                                    multiprocessing_context = self.unlabeled_multiprocessing_context,\n                                    generator = self.unlabeled_generator,\n                                    prefetch_factor = self.unlabeled_prefetch_factor,\n                                    persistent_workers = self.unlabeled_persistent_workers)\n            else:\n                self.unlabeled_dataloader = self.unlabeled_dataloader.init_dataloader(dataset=self.unlabeled_dataset,\n                                                                                  batch_sampler=self.unlabeled_batch_sampler)\n        else:\n            if self.unlabeled_dataloader is None:\n                self.unlabeled_dataloader=DataLoader(dataset=self.unlabeled_dataset,\n                                    batch_size=self.unlabeled_batch_size,\n                                    shuffle = False,\n                                    sampler = self.unlabeled_sampler,\n                                    num_workers = self.unlabeled_num_workers,\n                                    collate_fn = self.unlabeled_collate_fn,\n                                    pin_memory = self.unlabeled_pin_memory,\n                                    drop_last = self.unlabeled_drop_last,\n                                    timeout = self.unlabeled_timeout,\n                                    worker_init_fn = self.unlabeled_worker_init_fn,\n                                    multiprocessing_context = self.unlabeled_multiprocessing_context,\n                                    generator = self.unlabeled_generator,\n                                    prefetch_factor = self.unlabeled_prefetch_factor,\n                                    persistent_workers = self.unlabeled_persistent_workers)\n            else:\n                self.unlabeled_dataloader.batch_size = self.unlabeled_batch_size\n                self.unlabeled_dataloader = self.unlabeled_dataloader.init_dataloader(dataset=self.unlabeled_dataset,\n                                                                                  sampler=self.unlabeled_sampler)\n\n\n        return self.labeled_dataloader,self.unlabeled_dataloader\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataloader/UnlabeledDataloader.py",
    "content": "from torch.utils.data.dataloader import DataLoader\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom LAMDA_SSL.Sampler.BatchSampler import BatchSampler\nclass UnlabeledDataLoader:\n    def __init__(self,batch_size= 1,\n                 shuffle: bool = False, sampler = None,\n                 batch_sampler= None,\n                 num_workers: int = 0, collate_fn= None,\n                 pin_memory: bool = False, drop_last: bool = False,\n                 timeout: float = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor: int = 2,\n                 persistent_workers: bool = False):\n        # >> Parameter\n        # >> - batch_size: How many samples per batch to load.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - sampler: The sampler used when loading data.\n        # >> - batch_sampler: set to True to have the data reshuffled at every epoch.\n        # >> - num_workers: How many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.\n        # >> - collate_fn: Merges a list of samples to form a mini-batch of Tensor(s).  Used when using batched loading from a map-style dataset.\n        # >> - pin_memory: If True, the data loader will copy Tensors into CUDA pinned memory before returning them.  If your data elements are a custom type, or your :attr:'collate_fn' returns a batch that is a custom type, see the example below.\n        # >> - drop_last: Whether to discard redundant data that is not enough for a batch.\n        # >> - timeout: If positive, the timeout value for collecting a batch from workers. Should always be non-negative.\n        # >> - worker_init_fn: If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading.\n        # >> - multiprocessing_context: The context of multiprocessing.\n        # >> - generator: If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers.\n        # >> - prefetch_factor: Number of samples loaded in advance by each worker. '2' means there will be a total of 2 * num_workers samples prefetched across all workers.\n        # >> - persistent_workers: If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers 'Dataset' instances alive.\n        self.batch_size=batch_size\n        self.shuffle=shuffle\n        self.sampler=sampler\n        self.batch_sampler=batch_sampler\n        self.num_workers=num_workers\n        self.collate_fn=collate_fn\n        self.pin_memory=pin_memory\n        self.drop_last=drop_last\n        self.timeout=timeout\n        self.worker_init_fn=worker_init_fn\n        self.multiprocessing_context=multiprocessing_context\n        self.generator=generator\n        self.prefetch_factor=prefetch_factor\n        self.persistent_workers=persistent_workers\n        self.dataset=None\n        self.dataloader=None\n\n    def init_dataloader(self,dataset=None,sampler=None,batch_sampler=None):\n        self.dataset=dataset\n        if sampler is not None:\n            self.sampler=sampler\n        if isinstance(self.sampler,BaseSampler):\n            self.sampler=self.sampler.init_sampler(self.dataset)\n\n        if batch_sampler is not None:\n            self.batch_sampler=batch_sampler\n        if isinstance(self.batch_sampler,BatchSampler):\n            self.batch_sampler=self.batch_sampler.init_sampler(self.sampler)\n\n        if self.batch_sampler is None and self.sampler is None:\n            self.dataloader= DataLoader(dataset=self.dataset,\n                                batch_size=self.batch_size,\n                                shuffle = self.shuffle,\n                                sampler = self.sampler,\n                                batch_sampler = self.batch_sampler,\n                                num_workers = self.num_workers,\n                                collate_fn = self.collate_fn,\n                                pin_memory = self.pin_memory,\n                                drop_last = self.drop_last,\n                                timeout = self.timeout,\n                                worker_init_fn = self.worker_init_fn,\n                                multiprocessing_context = self.multiprocessing_context,\n                                generator = self.generator,\n                                prefetch_factor = self.prefetch_factor,\n                                persistent_workers = self.persistent_workers)\n        elif self.batch_sampler is not None:\n            self.dataloader = DataLoader(dataset=self.dataset,\n                                         batch_sampler=self.batch_sampler,\n                                         num_workers=self.num_workers,\n                                         collate_fn=self.collate_fn,\n                                         pin_memory=self.pin_memory,\n                                         timeout=self.timeout,\n                                         worker_init_fn=self.worker_init_fn,\n                                         multiprocessing_context=self.multiprocessing_context,\n                                         generator=self.generator,\n                                         prefetch_factor=self.prefetch_factor,\n                                         persistent_workers=self.persistent_workers)\n        else:\n            self.dataloader= DataLoader(dataset=self.dataset,\n                                batch_size=self.batch_size,\n                                shuffle = False,\n                                sampler = self.sampler,\n                                num_workers = self.num_workers,\n                                collate_fn = self.collate_fn,\n                                pin_memory = self.pin_memory,\n                                drop_last = self.drop_last,\n                                timeout = self.timeout,\n                                worker_init_fn = self.worker_init_fn,\n                                multiprocessing_context = self.multiprocessing_context,\n                                generator = self.generator,\n                                prefetch_factor = self.prefetch_factor,\n                                persistent_workers = self.persistent_workers)\n        return self.dataloader\n"
  },
  {
    "path": "LAMDA_SSL/Dataloader/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Dataset/Graph/Cora.py",
    "content": "import numpy as np\nfrom LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nimport torch\nimport copy\nfrom LAMDA_SSL.Base.GraphMixin import GraphMixin\nfrom torch_geometric.datasets.planetoid import Planetoid\nclass Cora(SemiDataset,GraphMixin):\n    # name='Cora'\n    # url = 'https://github.com/kimiyoung/planetoid/raw/master/data'\n    # names = ['x', 'tx', 'allx', 'y', 'ty', 'ally', 'graph', 'test.index']\n    # processed_file_names='data.pt'\n    def __init__(\n        self,\n        root: str,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        test_size=None,\n        valid_size=None,\n        labeled_size=None,\n        stratified=False,\n        shuffle=True,\n        random_state=None\n    ) -> None:\n        self.default_transforms=default_transforms\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.train_dataset=None\n        self.valid_dataset = None\n        self.test_dataset=None\n\n        self.data_initialized=False\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.valid_X_indexing_method=None\n        self.valid_indexing_method=None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n        self.root=root\n        self.dataset = Planetoid(root=root, name='Cora')\n\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,labeled_size=labeled_size,test_size=test_size,valid_size=valid_size,\n                             stratified=stratified,shuffle=shuffle,random_state=random_state)\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n\n\n\n    def _init_dataset(self):\n        self.data=self.dataset.data\n\n        self.data.train_mask.fill_(True)\n        train_X=np.arange(len(self.data.y))\n        train_y=self.data.y\n\n        if self.test_size is not None:\n            test_X, test_y, train_ind, train_y = DataSplit(X=train_X, y=train_y,\n                                                            size_split=self.test_size,\n                                                            stratified=self.stratified,\n                                                            shuffle=self.shuffle,\n                                                            random_state=self.random_state\n                                                            )\n        else:\n            test_X=None\n            test_y=None\n\n        if self.valid_size is not None:\n            valid_X, valid_y, train_X, train_y = DataSplit(X=train_X, y=train_y,\n                                                            size_split=self.valid_size,\n                                                            stratified=self.stratified,\n                                                            shuffle=self.shuffle,\n                                                            random_state=self.random_state\n                                                            )\n        else:\n            valid_X=None\n            valid_y=None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=train_X, y=train_y,\n                                                            size_split=self.labeled_size,\n                                                            stratified=self.stratified,\n                                                            shuffle=self.shuffle,\n                                                            random_state=self.random_state\n                                                            )\n        else:\n            labeled_X=train_X\n            labeled_y=train_y\n            unlabeled_X=None\n            unlabeled_y=None\n        self.train_X=train_X\n        self.train_y=train_y\n        self.labeled_X=labeled_X\n        self.labeled_y=labeled_y\n        self.unlabeled_X=unlabeled_X\n        self.unlabeled_y=unlabeled_y\n        self.valid_X=valid_X\n        self.valid_y=valid_y\n        self.test_X=test_X\n        self.test_y=test_y\n        self.data.unlabeled_mask = torch.zeros((len(self.data.y),), dtype=torch.bool)\n        self.data.labeled_mask = torch.zeros((len(self.data.y),), dtype=torch.bool)\n        self.data.train_mask.fill_(False)\n        self.data.unlabeled_mask.fill_(False)\n        self.data.labeled_mask.fill_(False)\n        self.data.test_mask.fill_(False)\n        self.data.val_mask.fill_(False)\n\n        if labeled_X is not None:\n            self.data.labeled_mask[labeled_X] = True\n        if unlabeled_X is not None:\n            self.data.unlabeled_mask[unlabeled_X] = True\n\n        if valid_X is not None:\n            self.data.val_mask[valid_X]=True\n        elif test_X is not None:\n            self.data.val_mask=copy.copy(self.data.test_mask)\n        else:\n            self.data.val_mask=copy.copy(self.data.unlabeled_mask)\n\n        if test_X is not None:\n            self.data.test_mask[test_X] = True\n        elif valid_X is not None:\n            self.data.test_mask=copy.copy(self.data.val_mask)\n        else:\n            self.data.test_mask = copy.copy(self.data.unlabeled_mask)\n\n\n        self.data.train_mask[self.data.labeled_mask|self.data.unlabeled_mask] = True\n\n\n        self.test_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X,test_y)\n        self.valid_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X,valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform,unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset=LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset=UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)\n\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Graph/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Dataset/LabeledDataset.py",
    "content": "import copy\nfrom LAMDA_SSL.utils import indexing\nfrom torch.utils.data.dataset import Dataset\nfrom LAMDA_SSL.utils import get_len,get_indexing_method\n\nclass LabeledDataset(Dataset):\n    def __init__(self,\n                 transforms=None,\n                 transform=None,\n                 target_transform=None,\n                 pre_transform=None\n                 ):\n        # >> Parameter\n        # >> - pre_transform: The way to preprocess X before augmentation.\n        # >> - transforms: The way to transform X and y at the same time after data augmentation.\n        # >> - transform: The way to transform X after data augmentation.\n        # >> - target_transform: The way to transform y after data augmentation.\n        self.transforms=transforms\n        self.transform=transform\n        self.pre_transform=pre_transform\n        self.target_transform=target_transform\n        self.X=None\n        self.y=None\n        self.len=None\n        self.X_indexing_method=None\n        self.y_indexing_method=None\n        self.data_initialized=False\n\n    def init_dataset(self, X=None, y=None):\n        self.X = X\n        self.y = y\n        self.len=get_len(self.X)\n        self.X_indexing_method = get_indexing_method(self.X)\n        self.y_indexing_method = get_indexing_method(self.y)\n        self.data_initialized = True\n        return self\n\n    def _transforms(self,X,y,transforms):\n        X, y = copy.deepcopy(X), copy.deepcopy(y)\n        if isinstance(transforms,(list,tuple)):\n            for item in transforms:\n                X,y=self._transforms(self.X,y,item)\n        elif callable(transforms):\n            X,y=transforms(X,y)\n        elif hasattr(transforms,'fit_transform'):\n            X,y=transforms.fit_transform(X,y)\n        elif hasattr(transforms, 'forward'):\n            X, y = transforms.forward(X, y)\n        elif hasattr(transforms,'transform'):\n            X, y = transforms.transform(X, y)\n        else:\n            raise Exception('Transforms is not Callable!')\n        return X,y\n\n    def to_list(self,l):\n        if isinstance(l, tuple):\n            l= list(l)\n        elif not isinstance(l,list):\n            l=[l]\n        return l\n\n    def insert(self,l,pos,item):\n        if isinstance(l,dict):\n            l[pos]=item\n        else:\n            l=self.to_list(l)\n            l = l[:pos] + [item] + l[pos:]\n        return l\n\n    def add_transform(self,transform,dim=1,x=0,y=0):\n        if transform is None and dim == 1:\n            return\n        if transform is None and dim == 0 and x==0:\n            return\n        if self.transform is None and dim==0 and x==0:\n            self.transform=transform\n        elif dim==0:\n            self.transform=self.insert(self.transform,x,transform)\n        else:\n            if not isinstance(self.transform, (dict, tuple, list)):\n                self.transform=[self.transform]\n            self.transform[x]=self.insert(self.transform[x],y,transform)\n\n    def add_pre_transform(self,transform,dim=1,x=0,y=0):\n        if transform is None and dim == 1:\n            return\n        if transform is None and dim == 0 and x==0:\n            return\n        if self.pre_transform is None and dim==0 and x==0:\n            self.pre_transform=transform\n        elif dim==0:\n            self.pre_transform=self.insert(self.pre_transform,x,transform)\n        else:\n            if not isinstance(self.pre_transform, (dict, tuple, list)):\n                self.pre_transform=[self.pre_transform]\n            self.pre_transform[x]=self.insert(self.pre_transform[x],y,transform)\n\n    def add_transforms(self,transforms,dim=1,x=0,y=0):\n        if transforms is None and dim == 1:\n            return\n        if transforms is None and dim == 0 and x==0:\n            return\n        if self.transforms is None and dim==0 and x==0:\n            self.transforms=transforms\n        elif dim==0:\n            self.transforms=self.insert(self.transforms,x,transforms)\n        else:\n            if not isinstance(self.transforms, (dict, tuple, list)):\n                self.transforms=[self.transforms]\n            self.transforms[x]=self.insert(self.transforms[x],y,transforms)\n\n    def add_target_transform(self,target_transform,dim=1,x=0,y=0):\n        if target_transform is None and dim == 1:\n            return\n        if target_transform is None and dim == 0 and x==0:\n            return\n        if self.target_transform is None and dim==0 and x==0:\n            self.target_transform=target_transform\n        elif dim==0:\n            self.target_transform=self.insert(self.target_transform,x,target_transform)\n        else:\n            if not isinstance(self.target_transform, (dict, tuple, list)):\n                self.target_transform=[self.target_transform]\n            self.target_transform[x]=self.insert(self.target_transform[x],y,target_transform)\n\n    def _transform(self,X,transform):\n        X = copy.deepcopy(X)\n        if isinstance(transform,(list,tuple)):\n            for item in transform:\n                X=self._transform(X,item)\n        elif callable(transform):\n            X = transform(X)\n        elif hasattr(transform,'fit_transform'):\n            X = transform.fit_transform(X)\n        elif hasattr(transform,'transform'):\n            X = transform.transform(X)\n        elif hasattr(transform,'forward'):\n            X = transform.forward(X)\n        else:\n            raise Exception('Transforms is not Callable!')\n        return X\n\n    def apply_transform(self,X,y):\n        if self.pre_transform is not None:\n            if isinstance(self.pre_transform,(tuple,list)):\n                list_X=[]\n                for item in self.pre_transform:\n                    _X=self._transform(X,item)\n                    list_X.append(_X)\n                X=list_X\n\n            elif isinstance(self.pre_transform,dict):\n                dict_X={}\n                for key, val in self.pre_transform.items():\n                    _X=self._transform(X,val)\n                    dict_X[key]=_X\n                X = dict_X\n            else:\n                X=self._transform(X,self.pre_transform)\n        if self.transforms is not None:\n            if isinstance(self.transforms,(tuple,list)):\n                list_X=[]\n                list_y=[]\n                for item in self.transforms:\n                    _X,_y=self._transforms(X,y,item)\n                    list_X.append(_X)\n                    list_y.append(_y)\n                X=list_X if len(list_X) is not 1 else list_X[0]\n                y=list_y if len(list_y) is not 1 else list_y[0]\n            elif isinstance(self.transforms,dict):\n                dict_X={}\n                dict_y={}\n                for key, val in self.transforms.items():\n                    _X,_y=self._transforms(X,y,val)\n                    dict_X[key]=_X\n                    dict_y[key]=_y\n                X = dict_X\n                y = dict_y\n            else:\n                X,y=self._transforms(X,y,self.transforms)\n        if self.transform is not None:\n            if isinstance(self.transform, (tuple, list)):\n                list_X = []\n                for item in self.transform:\n                    _X = self._transform(X, item)\n                    list_X.append(_X)\n                X = list_X\n            elif isinstance(self.transform, dict):\n                dict_X = {}\n                for key, val in self.transform.items():\n                    _X = self._transform(X, val)\n                    dict_X[key] = _X\n                X = dict_X\n            else:\n                X=self._transform(X,self.transform)\n        if self.target_transform is not None:\n            if isinstance(self.target_transform, (tuple, list)):\n                list_y = []\n                for item in self.target_transform:\n                    _y = self._transform(y, item)\n                    list_y.append(_y)\n                y = list_y\n            elif isinstance(self.target_transform, dict):\n                dict_y = {}\n                for key, val in self.target_transform.items():\n                    _y = self._transform(y, val)\n                    dict_y[key] = _y\n                y = dict_y\n            else:\n                y=self._transform(y,self.target_transform)\n        return X,y\n\n    def __getitem__(self, i):\n        X, y = self.X, self.y\n        Xi = indexing(X,i)\n        yi = indexing(y,i)\n        Xi, yi = self.apply_transform(Xi, yi)\n        return i,Xi, yi\n\n    def __len__(self):\n        return get_len(self.X) if self.len is None else self.len"
  },
  {
    "path": "LAMDA_SSL/Dataset/SemiDataset.py",
    "content": "from torch.utils.data import Dataset\nfrom .TrainDataset import TrainDataset\nfrom .LabeledDataset import LabeledDataset\nfrom .UnlabeledDataset import UnlabeledDataset\nfrom ..utils import get_indexing_method\nfrom ..Split.DataSplit import DataSplit\nimport copy\n\nclass SemiDataset(Dataset):\n    def __init__(self,\n                 transforms=None,\n                 transform=None,\n                 pre_transform=None,\n                 target_transform=None,\n                 unlabeled_transform=None,\n                 valid_transform=None,\n                 test_transform=None,\n                 test_size=None,\n                 valid_size=None,\n                 labeled_size=None,\n                 stratified=False,\n                 shuffle=True,\n                 random_state=None):\n        # >> Parameter\n        # >> - pre_transform: The way to preprocess X before augmentation.\n        # >> - transforms: The way to transform X and y at the same time after data augmentation.\n        # >> - transform: The way to transform X after data augmentation.\n        # >> - target_transform: The way to transform y after data augmentation.\n        # >> - unlabeled_transform: The way to transform unlabeled_X after data augmentation.\n        # >> - valid_transform: The way to transform valid X after data augmentation.\n        # >> - test_transform: The way to transform test X after data augmentation.\n        # >> - test_size: The number or proportion of test samples.\n        # >> - valid_size: The number or proportion of valid samples.\n        # >> - labeled_size: The number or proportion of labeled samples.\n        # >> - stratified: Whether to sample by class scale.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - random_state: The random seed.\n        self.transforms=transforms\n        self.transform = transform\n        self.pre_transform=pre_transform\n        self.target_transform=target_transform\n        self.unlabeled_transform = unlabeled_transform\n        self.valid_transform = valid_transform\n        self.test_transform = test_transform\n\n        self.labeled_size=labeled_size\n        self.valid_size=valid_size\n        self.test_size = test_size\n\n        self.stratified=stratified\n        self.shuffle=shuffle\n        self.random_state=random_state\n\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=self.transforms, transform=self.transform,\n                                          target_transform=self.target_transform)\n        self.unlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=self.unlabeled_transform)\n        self.train_dataset = TrainDataset(pre_transform=pre_transform,transforms=self.transforms, transform=self.transform,\n                                          target_transform=self.target_transform,\n                                          unlabeled_transform=self.unlabeled_transform,\n                                          labeled_size=self.labeled_size, stratified=self.stratified,\n                                          shuffle=self.shuffle, random_state=self.random_state)\n        self.valid_dataset = LabeledDataset(pre_transform=pre_transform,transform=self.valid_transform)\n        self.test_dataset=LabeledDataset(pre_transform=pre_transform,transform=self.test_transform)\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n        self.valid_X_indexing_method=None\n        self.valid_y_indexing_method=None\n\n        self.data_initialized=False\n\n    def _init_dataset(self):\n        raise NotImplementedError(\n            \"_init_dataset method of SemiDataset class must be implemented.\"\n        )\n\n    def init_dataset(self,labeled_X=None,labeled_y=None,unlabeled_X=None,\n                    unlabeled_y=None,test_X=None,test_y=None,valid_X=None,valid_y=None,train_dataset=None,\n                    test_dataset=None,valid_dataset=None,labeled_dataset=None,unlabeled_dataset=None):\n\n        if labeled_X is None and labeled_dataset is None and train_dataset is None:\n            self._init_dataset()\n        elif train_dataset is not None:\n            self.train_dataset = train_dataset\n            if test_dataset is not None:\n                self.test_dataset = test_dataset\n            elif test_X is not None:\n                self.test_dataset.init_dataset(test_X, test_y)\n            if valid_dataset is not None:\n                self.valid_dataset = valid_dataset\n            elif valid_X is not None:\n                self.valid_dataset.init_dataset(valid_X, valid_y)\n        else:\n            if labeled_dataset is not None:\n                labeled_X = getattr(labeled_dataset, 'X')\n                labeled_y = getattr(labeled_dataset, 'y')\n\n            if test_dataset is not None:\n                self.test_dataset=test_dataset\n\n            elif test_X is not None:\n                self.test_dataset.init_dataset(test_X,test_y)\n            elif self.test_size is not None:\n                test_X, test_y,labeled_X, labeled_y = DataSplit(X=labeled_X, y=labeled_y,\n                                                           size_split=self.test_size,\n                                                           stratified=self.stratified,\n                                                           shuffle=self.shuffle,\n                                                           random_state=self.random_state\n                                                        )\n                self.test_dataset.init_dataset(test_X, test_y)\n\n            if valid_dataset is not None:\n                self.valid_dataset=valid_dataset\n            elif valid_X is not None:\n                self.valid_dataset.init_dataset(valid_X,valid_y)\n            elif self.valid_size is not None:\n                if labeled_dataset is not None:\n                    labeled_X=getattr(labeled_dataset,'X')\n                    labeled_y=getattr(labeled_dataset,'y')\n\n                valid_X, valid_y,labeled_X, labeled_y = DataSplit(X=labeled_X, y=labeled_y,\n                                                           size_split=self.valid_size,\n                                                           stratified=self.stratified,\n                                                           shuffle=self.shuffle,\n                                                           random_state=self.random_state\n                                                           )\n                self.valid_dataset.init_dataset(valid_X, valid_y)\n\n            self.train_dataset.init_dataset(labeled_X=labeled_X,labeled_y=labeled_y,unlabeled_X=unlabeled_X,\n                    unlabeled_y=unlabeled_y,labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)\n\n        self.labeled_dataset=self.train_dataset.get_dataset(labeled=True)\n        self.unlabeled_dataset=self.train_dataset.get_dataset(labeled=False)\n\n        self.test_X = getattr(self.test_dataset,'X')\n        self.test_y = getattr(self.test_dataset,'y')\n        self.valid_X = getattr(self.valid_dataset,'X')\n        self.valid_y = getattr(self.valid_dataset,'y')\n        self.labeled_X=getattr(self.labeled_dataset,'X')\n        self.labeled_y = getattr(self.labeled_dataset,'y')\n        self.unlabeled_X = getattr(self.unlabeled_dataset,'X')\n        self.unlabeled_y = getattr(self.unlabeled_dataset,'y')\n        if self.valid_X is None and self.test_X is None:\n            self.valid_X =copy.copy(self.unlabeled_X)\n            self.valid_y=copy.copy(self.unlabeled_y)\n            self.valid_dataset.init_dataset(self.valid_X, self.valid_y)\n            self.test_X =copy.copy(self.unlabeled_X)\n            self.test_y=copy.copy(self.unlabeled_y)\n            self.test_dataset.init_dataset(self.test_X, self.test_y)\n        if self.valid_X is None:\n            self.valid_X =copy.copy(self.test_X)\n            self.valid_y=copy.copy(self.test_y)\n            self.valid_dataset.init_dataset(self.valid_X, self.valid_y)\n        if self.test_X is None:\n            self.test_X=copy.copy(self.valid_X)\n            self.test_y=copy.copy(self.valid_y)\n            self.test_dataset.init_dataset(self.test_X, self.test_y)\n        self.labeled_X_indexing_method=get_indexing_method(self.labeled_X)\n        self.labeled_y_indexing_method = get_indexing_method(self.labeled_y)\n        self.unlabeled_X_indexing_method =get_indexing_method(self.unlabeled_X)\n        self.unlabeled_y_indexing_method = get_indexing_method(self.unlabeled_y)\n        self.valid_X_indexing_method = get_indexing_method(self.valid_X)\n        self.valid_y_indexing_method = get_indexing_method(self.valid_y)\n        self.test_X_indexing_method = get_indexing_method(self.test_X)\n        self.test_y_indexing_method = get_indexing_method(self.test_y)\n\n        self.len_labeled=self.labeled_dataset.__len__()\n        self.len_unlabeled = self.unlabeled_dataset.__len__()\n        self.len_test = self.test_dataset.__len__()\n        self.len_valid = self.valid_dataset.__len__()\n        self.data_initialized=True\n        return self\n\n    def add_transform(self,transform,dim,x,y=0):\n        self.train_dataset.add_transform(transform,dim,x,y)\n\n    def add_target_transform(self,target_transform,dim,x,y=0):\n        self.train_dataset.add_target_transform(target_transform,dim,x,y)\n\n    def add_transforms(self,transforms,dim,x,y=0):\n        self.train_dataset.add_transforms(transforms, dim, x, y)\n\n    def add_unlabeled_transform(self,unlabeled_transform,dim,x,y=0):\n        self.train_dataset.add_unlabeled_transform(unlabeled_transform,dim,x,y)\n\n    def add_valid_transform(self,valid_transform,dim,x,y=0):\n        self.valid_dataset.add_transform(valid_transform,dim,x,y)\n\n    def add_test_transform(self,test_transform,dim,x,y=0):\n        self.test_dataset.add_transform(test_transform,dim,x,y)\n\n    def add_pre_transform(self,transform,dim,x,y=0):\n        self.train_dataset.add_pre_transform(transform, dim, x, y)\n        self.valid_dataset.add_pre_transform(transform, dim, x, y)\n        self.test_dataset.add_pre_transform(transform, dim, x, y)\n\n    def __getitem__(self, i, test=False,valid=False,labeled=True):\n        if test:\n            i,Xi,yi=self.test_dataset[i]\n        elif valid:\n            i,Xi, yi = self.valid_dataset[i]\n        elif labeled:\n            i,Xi,yi=self.labeled_dataset[i]\n        else:\n            i,Xi,yi= self.unlabeled_dataset[i]\n        return i,Xi,yi\n\n    def __len__(self,test=False,valid=False,labeled=True):\n        if test:\n            return self.len_test\n        elif valid:\n            return self.len_valid\n        elif labeled:\n            return self.len_labeled\n        else:\n            return self.len_unlabeled\n\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Tabular/Boston.py",
    "content": "from LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.TabularMixin import TabularMixin\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom sklearn import datasets\nimport numpy as np\n\nclass Boston(SemiDataset,TabularMixin):\n    def __init__(\n        self,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        test_size=None,\n        valid_size=None,\n        labeled_size=0.1,\n        stratified=False,\n        shuffle=True,\n        random_state=None,\n    ) -> None:\n        self.default_transforms=default_transforms\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.train_dataset=None\n        self.valid_dataset = None\n        self.test_dataset=None\n\n        self.data_initialized=False\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.valid_X_indexing_method=None\n        self.valid_indexing_method=None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n\n\n        self.dataset=datasets.load_boston()\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform,\n                             target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,labeled_size=labeled_size,valid_size=valid_size,test_size=test_size,\n                             stratified=stratified,shuffle=shuffle,random_state=random_state)\n        TabularMixin.__init__(self)\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n    def _init_dataset(self):\n        X, y = self.dataset.data, self.dataset.target.astype(np.float32)\n        if self.test_size is not None:\n            test_X, test_y, train_X, train_y = DataSplit(X=X, y=y,\n                                               size_split=self.test_size,\n                                               stratified=self.stratified,\n                                               shuffle=self.shuffle,\n                                               random_state=self.random_state\n                                               )\n        else:\n            test_X = None\n            test_y = None\n            train_X=X\n            train_y=y\n\n        if self.valid_size is not None:\n            valid_X, valid_y, train_X, train_y = DataSplit(X=train_X, y=train_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X=None\n            valid_y=None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=train_X,y=train_y,\n                                                                   size_split=self.labeled_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            labeled_X, labeled_y=train_X,train_y\n            unlabeled_X, unlabeled_y=None,None\n        self.test_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X,test_y)\n        self.valid_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X,valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform,unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset=LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset=UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)"
  },
  {
    "path": "LAMDA_SSL/Dataset/Tabular/BreastCancer.py",
    "content": "from LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.TabularMixin import TabularMixin\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom sklearn import datasets\nimport numpy as np\n\nclass BreastCancer(SemiDataset,TabularMixin):\n    def __init__(\n        self,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        test_size=None,\n        valid_size=None,\n        labeled_size=0.1,\n        stratified=False,\n        shuffle=True,\n        random_state=0,\n    ) -> None:\n        self.default_transforms=default_transforms\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.train_dataset=None\n        self.valid_dataset = None\n        self.test_dataset=None\n\n        self.data_initialized=False\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.valid_X_indexing_method=None\n        self.valid_indexing_method=None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n\n\n        self.dataset = datasets.load_breast_cancer()\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,labeled_size=labeled_size,test_size=test_size,\n                             valid_size=valid_size,stratified=stratified,shuffle=shuffle,random_state=random_state)\n        TabularMixin.__init__(self)\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n    def _init_dataset(self):\n        X, y = self.dataset.data, self.dataset.target.astype(np.float32)\n        if self.test_size is not None:\n            test_X, test_y, train_X, train_y = DataSplit(X=X, y=y,\n                                               size_split=self.test_size,\n                                               stratified=self.stratified,\n                                               shuffle=self.shuffle,\n                                               random_state=self.random_state\n                                               )\n        else:\n            test_X = None\n            test_y = None\n            train_X=X\n            train_y=y\n\n        if self.valid_size is not None:\n            valid_X, valid_y, train_X, train_y = DataSplit(X=train_X, y=train_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X=None\n            valid_y=None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=train_X,y=train_y,\n                                                                   size_split=self.labeled_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            labeled_X, labeled_y=train_X,train_y\n            unlabeled_X, unlabeled_y=None,None\n        self.test_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X,test_y)\n        self.valid_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X,valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform,unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset=LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset=UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)"
  },
  {
    "path": "LAMDA_SSL/Dataset/Tabular/Wine.py",
    "content": "from LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.TabularMixin import TabularMixin\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom sklearn import datasets\nimport numpy as np\n\nclass Wine(SemiDataset,TabularMixin):\n    def __init__(\n        self,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        test_size=None,\n        valid_size=None,\n        labeled_size=0.1,\n        stratified=False,\n        shuffle=True,\n        random_state=None,\n    ) -> None:\n        self.default_transforms=default_transforms\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.train_dataset=None\n        self.valid_dataset = None\n        self.test_dataset=None\n\n        self.data_initialized=False\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.valid_X_indexing_method=None\n        self.valid_indexing_method=None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n\n\n        self.dataset=datasets.load_wine()\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,labeled_size=labeled_size,test_size=test_size,\n                             valid_size=valid_size,stratified=stratified,shuffle=shuffle,random_state=random_state)\n        TabularMixin.__init__(self)\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n    def _init_dataset(self):\n        X, y = self.dataset.data, self.dataset.target.astype(np.float32)\n        if self.test_size is not None:\n            test_X, test_y, train_X, train_y = DataSplit(X=X, y=y,\n                                               size_split=self.test_size,\n                                               stratified=self.stratified,\n                                               shuffle=self.shuffle,\n                                               random_state=self.random_state\n                                               )\n        else:\n            test_X = None\n            test_y = None\n            train_X=X\n            train_y=y\n\n        if self.valid_size is not None:\n            valid_X, valid_y, train_X, train_y = DataSplit(X=train_X, y=train_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X=None\n            valid_y=None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=train_X,y=train_y,\n                                                                   size_split=self.labeled_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            labeled_X, labeled_y=train_X,train_y\n            unlabeled_X, unlabeled_y=None,None\n        self.test_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X,test_y)\n        self.valid_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X,valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform,unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset=LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset=UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)"
  },
  {
    "path": "LAMDA_SSL/Dataset/Tabular/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Dataset/Text/IMDB.py",
    "content": "from LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.TextMixin import TextMixin\nfrom torchtext.utils import download_from_url,extract_archive\nimport io\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nimport os\n\nclass  IMDB(SemiDataset,TextMixin):\n    URL = \"http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz\"\n    MD5 = \"7c2ac02c03563afcf9b574c7e56c153a\"\n    NUM_LINES = {\n        \"train\": 25000,\n        \"test\": 25000,\n        \"unsup\": 50000,\n    }\n    _PATH = \"aclImdb_v1.tar.gz\"\n    DATASET_NAME = \"IMDB\"\n    def __init__(self,root,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        valid_size=None,\n        stratified=False,\n        shuffle=True,\n        random_state=None,\n        download: bool = False,\n        word_vocab=None, vectors=None, length=300, unk_token='<unk>', pad_token='<pad>',\n        min_freq=1, special_first=True, default_index=None):\n\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,valid_size=valid_size,\n                             stratified=stratified,shuffle=shuffle,random_state=random_state)\n\n        TextMixin.__init__(self,length=length,vectors=vectors,word_vocab=word_vocab,unk_token=unk_token,\n                               pad_token=pad_token,min_freq=min_freq,special_first=special_first,default_index=default_index)\n        self.root=root\n        self.default_transforms=default_transforms\n        self.classes=['neg','pos']\n        self.class_to_idx={'neg':0,'pos':1}\n\n        if download:\n            self.download()\n\n\n        walk = os.walk(os.path.join(self.root,'aclImdb'))\n        self.extracted_files = []\n        for root, dirs, files in walk:\n            for item in files:\n                self.extracted_files.append(os.path.join(root, item))\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n\n    def download(self):\n        dataset_tar = download_from_url(self.URL,root=self.root,\n                                    hash_value=self.MD5, hash_type='md5')\n        extract_archive(dataset_tar)\n\n\n    def _init_dataset(self):\n        test_X=[]\n        test_y=[]\n        labeled_X=[]\n        labeled_y=[]\n        unlabeled_X=[]\n        for fname in self.extracted_files:\n            if 'urls' in fname or 'Bow' in fname:\n                continue\n            if 'train' in fname:\n                if 'pos' in fname :\n                    with io.open(fname, encoding=\"utf8\") as f:\n                        labeled_X.append(f.read())\n                    labeled_y.append(1)\n                elif 'neg' in fname:\n                    with io.open(fname, encoding=\"utf8\") as f:\n                        labeled_X.append(f.read())\n                    labeled_y.append(0)\n                elif 'unsup' in fname:\n                    with io.open(fname, encoding=\"utf8\") as f:\n                        unlabeled_X.append(f.read())\n\n            elif 'test' in fname:\n                if 'pos' in fname :\n                    with io.open(fname, encoding=\"utf8\") as f:\n                        test_X.append(f.read())\n                    test_y.append(1)\n                elif 'neg' in fname:\n                    with io.open(fname, encoding=\"utf8\") as f:\n                        test_X.append(f.read())\n                    test_y.append(0)\n\n        if self.valid_size is not None:\n            valid_X, valid_y, labeled_X, labeled_y = DataSplit(X=labeled_X, y=labeled_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X = None\n            valid_y = None\n\n        self.test_dataset = LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X, test_y)\n        self.valid_dataset = LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X, valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms, transform=self.transform,\n                                          target_transform=self.target_transform,\n                                          unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset = LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms, transform=self.transform,\n                                       target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset = UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Text/SST2.py",
    "content": "from LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.TextMixin import TextMixin\nfrom torchtext.utils import download_from_url,extract_archive\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nimport os\n\nclass  SST2(SemiDataset,TextMixin):\n    URL = \"https://dl.fbaipublicfiles.com/glue/data/SST-2.zip\"\n    MD5 = \"9f81648d4199384278b86e315dac217c\"\n    NUM_LINES = {\n        \"train\": 67349,\n        \"dev\": 872,\n        \"test\": 1821,\n    }\n    path= {\n        \"train\": os.path.join(\"SST-2\", \"train.tsv\"),\n        \"dev\": os.path.join(\"SST-2\", \"dev.tsv\"),\n        \"test\": os.path.join(\"SST-2\", \"test.tsv\"),\n    }\n    def __init__(self,root,\n        default_transforms = False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        labeled_size=None,\n        valid_size=None,\n        stratified=False,\n        shuffle=True,\n        random_state=None,\n        download: bool = False,\n        word_vocab=None, vectors=None, length=50, unk_token='<unk>', pad_token='<pad>',\n        min_freq=1, special_first=True, default_index=None):\n\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,valid_size=valid_size,labeled_size=labeled_size,\n                             stratified=stratified,shuffle=shuffle,random_state=random_state)\n\n\n        self.default_transforms=default_transforms\n        self.root=root\n\n        if download:\n            self.download()\n        self.init_dataset()\n        TextMixin.__init__(self,length=length,vectors=vectors,word_vocab=word_vocab,unk_token=unk_token,\n                               pad_token=pad_token,min_freq=min_freq,special_first=special_first,default_index=default_index)\n        if self.default_transforms:\n            self.init_default_transforms()\n\n\n\n\n    def download(self):\n        dataset_tar = download_from_url(self.URL,root=self.root,\n                                    hash_value=self.MD5, hash_type='md5')\n        extract_archive(dataset_tar)\n\n\n    def _init_dataset(self):\n        test_X=[]\n        test_y=[]\n        labeled_X=[]\n        labeled_y=[]\n        unlabeled_X=[]\n        train_path=os.path.join(self.root,self.path['train'])\n        with open(train_path) as infile:\n            for line in infile:\n                tsplit = line.split(\"\\t\")\n                if tsplit[0]=='sentence':\n                    continue\n                labeled_X.append(tsplit[0])\n                labeled_y.append(int(tsplit[1]))\n\n        test_path=os.path.join(self.root,self.path['dev'])\n        with open(test_path) as infile:\n            for line in infile:\n                tsplit = line.split(\"\\t\")\n                if tsplit[0]=='sentence':\n                    continue\n                test_X.append(tsplit[0])\n                test_y.append(int(tsplit[1]))\n\n        unlabeled_path=os.path.join(self.root,self.path['test'])\n        with open(unlabeled_path) as infile:\n            for line in infile:\n                tsplit = line.split(\"\\t\")\n                if tsplit[0]=='index':\n                    continue\n                unlabeled_X.append(tsplit[1])\n\n\n        if self.valid_size is not None:\n            valid_X, valid_y, labeled_X, labeled_y = DataSplit(X=labeled_X, y=labeled_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X = None\n            valid_y = None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X,unlabeled_y = DataSplit(X=labeled_X, y=labeled_y,\n                                                               size_split=self.labeled_size,\n                                                               stratified=self.stratified,\n                                                               shuffle=self.shuffle,\n                                                               random_state=self.random_state\n                                                               )\n        else:\n            valid_X = None\n            valid_y = None\n\n\n        self.test_dataset = LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X, test_y)\n        self.valid_dataset = LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X, valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms, transform=self.transform,\n                                          target_transform=self.target_transform,\n                                          unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset = LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms, transform=self.transform,\n                                       target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset = UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset, unlabeled_dataset=unlabeled_dataset)\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Text/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Dataset/TrainDataset.py",
    "content": "from torch.utils.data import Dataset\nfrom .LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom ..Split.DataSplit import DataSplit\n\nclass TrainDataset(Dataset):\n    def __init__(self,\n                 transforms=None,\n                 transform=None,\n                 pre_transform=None,\n                 target_transform=None,\n                 unlabeled_transform=None,\n                 labeled_size=None,\n                 stratified=False,\n                 shuffle=True,\n                 random_state=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None\n                 ):\n        # >> Parameter\n        # >> - pre_transform: The way to preprocess X before augmentation.\n        # >> - transforms: The way to transform X and y at the same time after data augmentation.\n        # >> - transform: The way to transform X after data augmentation.\n        # >> - target_transform: The way to transform y after data augmentation.\n        # >> - unlabeled_transform: The way to transform unlabeled_X after data augmentation.\n        # >> - labeled_size: The number or proportion of labeled samples.\n        # >> - stratified: Whether to sample by class scale.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - random_state: The random seed.\n        # >> - labeled_dataset: The labeled dataset.\n        # >> - unlabeled_dataset: The unlabeled dataset.\n\n        self.labeled_size=labeled_size\n        self.stratified=stratified\n        self.shuffle=shuffle\n        self.random_state=random_state\n\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.len_labeled=None\n        self.len_unlabeled=None\n        self.labeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,transform=transform,\n                                          target_transform=target_transform) if labeled_dataset is None else labeled_dataset\n        self.unlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)if unlabeled_dataset is None else unlabeled_dataset\n        self.pre_transform=self.labeled_dataset.pre_transform\n        self.transforms=self.labeled_dataset.transforms\n        self.transform = self.labeled_dataset.transform\n        self.target_transform=self.labeled_dataset.target_transform\n        self.unlabeled_transform = self.unlabeled_dataset.transform\n        self.data_initialized=False\n\n\n    def _init_dataset(self):\n        raise NotImplementedError(\n            \"_init_dataset method of SemiTrainDataset class must be implemented.\"\n        )\n\n    def init_dataset(self,labeled_X=None,labeled_y=None,unlabeled_X=None,\n                    unlabeled_y=None,labeled_dataset=None,unlabeled_dataset=None):\n        if labeled_X is not None:\n            if unlabeled_X is None and self.labeled_size is not None:\n                labeled_X,labeled_y,unlabeled_X,unlabeled_y=DataSplit(X=labeled_X,y=labeled_y,\n                                                                size_split=self.labeled_size,\n                                                                stratified=self.stratified,\n                                                                shuffle=self.shuffle,\n                                                                random_state=self.random_state\n                                                                )\n            self.unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n            self.labeled_dataset.init_dataset(labeled_X,labeled_y)\n\n        elif labeled_dataset is not None:\n            if unlabeled_dataset is not None:\n                self.unlabeled_dataset=unlabeled_dataset\n                self.labeled_dataset=labeled_dataset\n            elif self.labeled_size is not None:\n                labeled_X=getattr(labeled_dataset,'X')\n                labeled_y=getattr(labeled_dataset,'y')\n                labeled_X,labeled_y,unlabeled_X,unlabeled_y=DataSplit(X=labeled_X,y=labeled_y,\n                                                                size_split=self.labeled_size,\n                                                                stratified=self.stratified,\n                                                                shuffle=self.shuffle,\n                                                                random_state=self.random_state)\n                self.unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n                self.labeled_dataset.init_dataset(labeled_X, labeled_y)\n        else:\n            self._init_dataset()\n\n        self.labeled_X = getattr(self.labeled_dataset,'X')\n        self.labeled_y = getattr(self.labeled_dataset,'y')\n        self.unlabeled_X = getattr(self.unlabeled_dataset,'X')\n        self.unlabeled_y = getattr(self.unlabeled_dataset,'y')\n        self.len_labeled=self.labeled_dataset.__len__()\n        self.len_unlabeled = self.unlabeled_dataset.__len__()\n        self.data_initialized=True\n        return self\n\n    def add_transform(self,transform,dim,x,y):\n        self.labeled_dataset.add_transform(transform,dim,x,y=0)\n\n    def add_target_transform(self,target_transform,dim,x,y=0):\n        self.labeled_dataset.add_target_transform(target_transform,dim,x,y)\n\n    def add_transforms(self,transforms,dim,x,y=0):\n        self.labeled_dataset.add_transforms(transforms, dim, x, y)\n\n    def add_pre_transform(self,transform,dim,x,y=0):\n        self.labeled_dataset.add_pre_transform(transform, dim, x, y)\n        self.unlabeled_dataset.add_pre_transform(transform, dim, x, y)\n\n    def add_unlabeled_transform(self,unlabeled_transform,dim,x,y=0):\n        self.unlabeled_dataset.add_transform(unlabeled_transform,dim,x,y)\n\n    def get_dataset(self,labeled):\n        if labeled:\n            return self.labeled_dataset\n        else:\n            return self.unlabeled_dataset\n\n    def __getitem__(self, i, labeled=True):\n        if labeled:\n            i,Xi,yi=self.labeled_dataset[i]\n        else:\n            i,Xi,yi=self.unlabeled_dataset[i]\n        return i, Xi, yi\n\n    def __len__(self,labeled=True):\n        if labeled:\n            return self.len_labeled\n        else:\n            return self.len_unlabeled\n\n\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/UnlabeledDataset.py",
    "content": "import copy\nimport torch\nfrom LAMDA_SSL.utils import indexing\nfrom torch.utils.data.dataset import Dataset\nfrom LAMDA_SSL.utils import get_len,get_indexing_method\n\nclass UnlabeledDataset(Dataset):\n    def __init__(self,\n                 pre_transform=None,\n                 transform=None\n                 ):\n        # >> Parameter\n        # >> - pre_transform: The way to preprocess X before augmentation.\n        # >> - transform: The way to transform X after data augmentation.\n        self.transform=transform\n        self.pre_transform = pre_transform\n        self.X=None\n        self.y=None\n        self.len=None\n        self.X_indexing_method=None\n        self.y_indexing_method=None\n        self.data_initialized=False\n\n    def init_dataset(self, X=None, y=None):\n        self.X = X\n        self.y = y\n        self.len=get_len(X)\n        self.X_indexing_method = get_indexing_method(self.X)\n        self.y_indexing_method = get_indexing_method(self.y)\n        self.data_initialized = True\n        return self\n\n    def to_list(self,l):\n        if isinstance(l, tuple):\n            l= list(l)\n        elif not isinstance(l,list):\n            l=[l]\n        return l\n\n    def insert(self,l,pos,item):\n        if l is None and pos==0:\n            l=item\n        elif isinstance(l,dict):\n            l[pos]=item\n        else:\n            l=self.to_list(l)\n            l = l[:pos] + [item] + l[pos:]\n        return l\n\n    def add_transform(self,transform,dim=1,x=0,y=0):\n        if transform is None and dim == 1:\n            return\n        if transform is None and dim == 0 and x==0:\n            return\n        if self.transform is None and dim==0 and x==0:\n            self.transform=transform\n        elif dim==0:\n            self.transform=self.insert(self.transform,x,transform)\n        else:\n            if not isinstance(self.transform, (dict, tuple, list)):\n                self.transform=[self.transform]\n            self.transform[x]=self.insert(self.transform[x],y,transform)\n\n    def add_pre_transform(self,transform,dim=1,x=0,y=0):\n        if transform is None and dim == 1:\n            return\n        if transform is None and dim == 0 and x==0:\n            return\n        if self.pre_transform is None and dim==0 and x==0:\n            self.pre_transform=transform\n        elif dim==0:\n            self.pre_transform=self.insert(self.pre_transform,x,transform)\n        else:\n            if not isinstance(self.pre_transform, (dict, tuple, list)):\n                self.pre_transform=[self.pre_transform]\n            self.pre_transform[x]=self.insert(self.pre_transform[x],y,transform)\n\n    def _transform(self,X,transform):\n\n        if isinstance(transform,(list,tuple)):\n            for item in transform:\n                X=self._transform(X,item)\n        elif callable(transform):\n            X = transform(X)\n        elif hasattr(transform,'fit_transform'):\n            X = transform.fit_transform(X)\n        elif hasattr(transform,'transform'):\n            X = transform.transform(X)\n        elif hasattr(transform,'forward'):\n            X = transform.forward(X)\n        else:\n            raise Exception('Transforms is not Callable!')\n        return X\n\n    def apply_transform(self,X,y=None):\n        if self.pre_transform is not None:\n            if isinstance(self.pre_transform,(tuple,list)):\n                list_X=[]\n                for item in self.pre_transform:\n                    _X=self._transform(X,item)\n                    list_X.append(_X)\n                X=list_X\n\n            elif isinstance(self.pre_transform,dict):\n                dict_X={}\n                for key, val in self.pre_transform.items():\n                    _X=self._transform(X,val)\n                    dict_X[key]=_X\n                X = dict_X\n\n            else:\n                X=self._transform(X,self.pre_transform)\n\n        if self.transform is not None:\n\n            if isinstance(self.transform, (tuple, list)):\n                list_X = []\n                for item in self.transform:\n                    # print(item)\n                    _X = self._transform(X, item)\n                    list_X.append(_X)\n                X = list_X\n\n            elif isinstance(self.transform, dict):\n                dict_X = {}\n                for key, val in self.transform.items():\n                    _X = self._transform(X, val)\n                    dict_X[key] = _X\n                X = dict_X\n            else:\n                X=self._transform(X,self.transform)\n        y=torch.Tensor([-1]) if y is None else y\n        return X,y\n\n    def __getitem__(self, i):\n        X, y = self.X, self.y\n\n        Xi = indexing(X,i)\n        yi = indexing(y,i)\n        Xi = copy.deepcopy(Xi)\n        yi=copy.deepcopy(yi)\n\n        Xi, yi = self.apply_transform(Xi, yi)\n        return i,Xi, yi\n\n    def __len__(self):\n        return get_len(self.X) if self.len is None else self.len"
  },
  {
    "path": "LAMDA_SSL/Dataset/Vision/CIFAR10.py",
    "content": "import numpy as np\nfrom LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.VisionMixin import VisionMixin\nfrom torchvision.datasets.utils import check_integrity, download_and_extract_archive\nimport os\nimport pickle\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\nclass CIFAR10(SemiDataset,VisionMixin):\n    base_folder = \"cifar-10-batches-py\"\n    url = \"https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\"\n    filename = \"cifar-10-python.tar.gz\"\n    tgz_md5 = \"c58f30108f718f92721af3b95e74349a\"\n    train_list = [\n        [\"data_batch_1\", \"c99cafc152244af753f735de768cd75f\"],\n        [\"data_batch_2\", \"d4bba439e000b95fd0a9bffe97cbabec\"],\n        [\"data_batch_3\", \"54ebc095f3ab1f0389bbae665268c751\"],\n        [\"data_batch_4\", \"634d18415352ddfa80567beed471001a\"],\n        [\"data_batch_5\", \"482c414d41f54cd18b22e5b47cb7c3cb\"],\n    ]\n\n    test_list = [\n        [\"test_batch\", \"40351d587109b95175f43aff81a1287e\"],\n    ]\n    meta = {\n        \"filename\": \"batches.meta\",\n        \"key\": \"label_names\",\n        \"md5\": \"5ff9c542aee3614f3951f8cda6e48888\",\n    }\n    mean=[0.4914, 0.4822, 0.4465]\n    std=[0.2471, 0.2435, 0.2616]\n\n    def __init__(\n        self,\n        root: str,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        valid_size=None,\n        labeled_size=0.1,\n        stratified=False,\n        shuffle=True,\n        random_state=None,\n        download: bool = False,\n\n    ) -> None:\n        self.default_transforms=default_transforms\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.train_dataset=None\n        self.valid_dataset = None\n        self.test_dataset=None\n\n        self.data_initialized=False\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.valid_X_indexing_method=None\n        self.valid_indexing_method=None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n\n\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,labeled_size=labeled_size,valid_size=valid_size,\n                             stratified=stratified,shuffle=shuffle,random_state=random_state)\n        VisionMixin.__init__(self,mean=self.mean,std=self.std)\n\n\n        if isinstance(root, (str, bytes)):\n            root = os.path.expanduser(root)\n        self.root = root\n\n        if download:\n            self.download()\n\n        if not self._check_integrity():\n            raise RuntimeError(\"Dataset not found or corrupted. You can use download=True to download it\")\n\n        self._load_meta()\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n    def _load_meta(self) -> None:\n        path = os.path.join(self.root, self.base_folder, self.meta[\"filename\"])\n        if not check_integrity(path, self.meta[\"md5\"]):\n            raise RuntimeError(\"Dataset metadata file not found or corrupted. You can use download=True to download it\")\n        with open(path, \"rb\") as infile:\n            data = pickle.load(infile, encoding=\"latin1\")\n            self.classes = data[self.meta[\"key\"]]\n        self.class_to_idx = {_class: i for i, _class in enumerate(self.classes)}\n\n    def _check_integrity(self) -> bool:\n        root = self.root\n        for fentry in self.train_list + self.test_list:\n            filename, md5 = fentry[0], fentry[1]\n            fpath = os.path.join(root, self.base_folder, filename)\n            if not check_integrity(fpath, md5):\n                return False\n        return True\n\n    def download(self) -> None:\n        if self._check_integrity():\n            print(\"Files already downloaded and verified\")\n            return\n        download_and_extract_archive(self.url, self.root, filename=self.filename, md5=self.tgz_md5)\n\n    def _init_dataset(self):\n        test_X = []\n        test_y = []\n        for file_name, checksum in self.test_list:\n            file_path = os.path.join(self.root, self.base_folder, file_name)\n            with open(file_path, \"rb\") as f:\n                entry = pickle.load(f, encoding=\"latin1\")\n                test_X.append(entry[\"data\"])\n                if \"labels\" in entry:\n                    test_y.extend(entry[\"labels\"])\n                else:\n                    test_y.extend(entry[\"fine_labels\"])\n        test_X = np.vstack(test_X).reshape(-1, 3, 32, 32)\n        test_X = test_X.transpose((0, 2, 3, 1))\n\n        train_X = []\n        train_y = []\n        for file_name, checksum in self.train_list:\n            file_path = os.path.join(self.root, self.base_folder, file_name)\n            with open(file_path, \"rb\") as f:\n                entry = pickle.load(f, encoding=\"latin1\")\n                train_X.append(entry[\"data\"])\n                if \"labels\" in entry:\n                    train_y.extend(entry[\"labels\"])\n                else:\n                    train_y.extend(entry[\"fine_labels\"])\n        train_X = np.vstack(train_X).reshape(-1, 3, 32, 32)\n        train_X = train_X.transpose((0, 2, 3, 1))\n\n        if self.valid_size is not None:\n            valid_X, valid_y, train_X, train_y = DataSplit(X=train_X, y=train_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X=None\n            valid_y=None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=train_X,y=train_y,\n                                                                   size_split=self.labeled_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            labeled_X, labeled_y=train_X,train_y\n            unlabeled_X, unlabeled_y=None,None\n        self.test_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X,test_y)\n        self.valid_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X,valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform,unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset=LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset=UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Vision/ImageCLEF.py",
    "content": "import os\r\nfrom PIL import Image\r\nfrom torch.utils.data.dataset import Dataset\r\ndef make_dataset_with_labels(dir, classnames):\r\n    images = []\r\n    labels = []\r\n    for root, _, fnames in sorted(os.walk(dir, followlinks=True)):\r\n        for fname in fnames:\r\n            dirname = os.path.split(root)[-1]\r\n            if dirname not in classnames:\r\n                continue\r\n\r\n            label = classnames.index(dirname)\r\n\r\n            path = os.path.join(root, fname)\r\n            images.append(path)\r\n            labels.append(label)\r\n    return images, labels\r\n\r\nclasses=['0', '1', '2', '3',\r\n        '4', '5', '6', '7',\r\n        '8', '9', '10', '11']\r\n\r\nclass ImageCLEF(Dataset):\r\n    def __init__(self, root, domain='webcam', transform=None,classnames=classes):\r\n        super(ImageCLEF, self).__init__()\r\n        self.root=root\r\n        self.domain=domain\r\n        self.transform=transform\r\n        self.data_paths = []\r\n        self.data_labels = []\r\n        self.data_root=os.path.join(self.root, self.domain)\r\n        self.classnames = classnames\r\n        self.data_paths, self.data_labels = make_dataset_with_labels(self.data_root, self.classnames)\r\n        self.imgs=[]\r\n        for index in range(len(self.data_paths)):\r\n            path = self.data_paths[index]\r\n            img = Image.open(path).convert('RGB')\r\n            self.imgs.append(img)\r\n        assert(len(self.data_paths) == len(self.data_labels)), \\\r\n            'The number of images (%d) should be equal to the number of labels (%d).' % \\\r\n            (len(self.data_paths), len(self.data_labels))\r\n\r\n    def __getitem__(self, index):\r\n        img=self.imgs[index]\r\n        if self.transform is not None:\r\n            img = self.transform(img)\r\n        label = self.data_labels[index]\r\n        return img, label\r\n\r\n    def make_dataset_classwise(self, category):\r\n        imgs=[]\r\n        labels=[]\r\n        for _ in range(len(self.data_labels)):\r\n            if self.data_labels[_]==category:\r\n                imgs.append(self.imgs[_])\r\n                labels.append(self.data_labels[_])\r\n        return imgs,labels\r\n\r\n    def __len__(self):\r\n        return len(self.data_paths)\r\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Vision/Mnist.py",
    "content": "from LAMDA_SSL.Dataset.SemiDataset import SemiDataset\nfrom LAMDA_SSL.Base.VisionMixin import VisionMixin\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\nfrom LAMDA_SSL.Dataset.TrainDataset import TrainDataset\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom torchvision.datasets import mnist\n\nclass Mnist(SemiDataset,VisionMixin):\n    def __init__(\n        self,\n        root: str,\n        default_transforms=False,\n        pre_transform=None,\n        transforms=None,\n        transform = None,\n        target_transform = None,\n        unlabeled_transform=None,\n        valid_transform=None,\n        test_transform=None,\n        valid_size=None,\n        labeled_size=0.1,\n        stratified=False,\n        shuffle=True,\n        random_state=None,\n        download: bool = False,\n    ) -> None:\n        self.default_transforms=default_transforms\n        self.labeled_X=None\n        self.labeled_y=None\n        self.unlabeled_X=None\n        self.unlabeled_y=None\n        self.valid_X=None\n        self.valid_y=None\n        self.test_X=None\n        self.test_y=None\n\n        self.labeled_dataset=None\n        self.unlabeled_dataset=None\n        self.train_dataset=None\n        self.valid_dataset = None\n        self.test_dataset=None\n\n        self.data_initialized=False\n\n        self.len_test=None\n        self.len_valid = None\n        self.len_labeled=None\n        self.len_unlabeled=None\n\n        self.labeled_X_indexing_method=None\n        self.labeled_y_indexing_method =None\n        self.unlabeled_X_indexing_method =None\n        self.unlabeled_y_indexing_method =None\n        self.valid_X_indexing_method=None\n        self.valid_indexing_method=None\n        self.test_X_indexing_method=None\n        self.test_y_indexing_method=None\n        self.min_val=0\n        self.max_val=255\n\n        self.train_data=mnist.MNIST(root=root,download=download,train=True)\n        self.test_data=mnist.MNIST(root=root,download=False,train=False)\n        SemiDataset.__init__(self,pre_transform=pre_transform,transforms=transforms,transform=transform, target_transform=target_transform,\n                             unlabeled_transform=unlabeled_transform,test_transform=test_transform,\n                             valid_transform=valid_transform,labeled_size=labeled_size,valid_size=valid_size,\n                             stratified=stratified,shuffle=shuffle,random_state=random_state)\n        VisionMixin.__init__(self)\n        if self.default_transforms:\n            self.init_default_transforms()\n        self.init_dataset()\n\n    def init_default_transforms(self):\n        self.transforms=None\n        self.target_transform=None\n        self.pre_transform=ToImage(channels=1,channels_first=False)\n        self.transform=ToTensor(dtype='float',image=True)\n        self.unlabeled_transform=ToTensor(dtype='float',image=True)\n        self.test_transform=ToTensor(dtype='float',image=True)\n        self.valid_transform=ToTensor(dtype='float',image=True)\n        return self\n\n    def _init_dataset(self):\n\n        test_X, test_y = self.test_data.data, self.test_data.targets\n        train_X, train_y = self.train_data.data, self.train_data.targets\n        if self.valid_size is not None:\n            valid_X, valid_y, train_X, train_y = DataSplit(X=train_X, y=train_y,\n                                                                   size_split=self.valid_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            valid_X=None\n            valid_y=None\n\n        if self.labeled_size is not None:\n            labeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=train_X,y=train_y,\n                                                                   size_split=self.labeled_size,\n                                                                   stratified=self.stratified,\n                                                                   shuffle=self.shuffle,\n                                                                   random_state=self.random_state\n                                                                   )\n        else:\n            labeled_X, labeled_y=train_X,train_y\n            unlabeled_X, unlabeled_y=None,None\n        self.test_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.test_transform)\n        self.test_dataset.init_dataset(test_X,test_y)\n        self.valid_dataset=LabeledDataset(pre_transform=self.pre_transform,transform=self.valid_transform)\n        self.valid_dataset.init_dataset(valid_X,valid_y)\n        self.train_dataset = TrainDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform,unlabeled_transform=self.unlabeled_transform)\n        labeled_dataset=LabeledDataset(pre_transform=self.pre_transform,transforms=self.transforms,transform=self.transform,\n                                          target_transform=self.target_transform)\n        labeled_dataset.init_dataset(labeled_X, labeled_y)\n        unlabeled_dataset=UnlabeledDataset(pre_transform=self.pre_transform,transform=self.unlabeled_transform)\n        unlabeled_dataset.init_dataset(unlabeled_X, unlabeled_y)\n        self.train_dataset.init_dataset(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset)"
  },
  {
    "path": "LAMDA_SSL/Dataset/Vision/Office31.py",
    "content": "import os\r\nfrom PIL import Image\r\nfrom torch.utils.data.dataset import Dataset\r\ndef make_dataset_with_labels(dir, classnames):\r\n    images = []\r\n    labels = []\r\n    for root, _, fnames in sorted(os.walk(dir, followlinks=True)):\r\n        for fname in fnames:\r\n            dirname = os.path.split(root)[-1]\r\n            if dirname not in classnames:\r\n                continue\r\n\r\n            label = classnames.index(dirname)\r\n\r\n            path = os.path.join(root, fname)\r\n            images.append(path)\r\n            labels.append(label)\r\n    return images, labels\r\n\r\nclasses=['back_pack', 'bike', 'bike_helmet', 'bookcase', 'bottle',\r\n            'calculator', 'desk_chair', 'desk_lamp', 'desktop_computer',\r\n            'file_cabinet', 'headphones', 'keyboard', 'laptop_computer',\r\n            'letter_tray', 'mobile_phone', 'monitor', 'mouse', 'mug',\r\n            'paper_notebook', 'pen', 'phone', 'printer', 'projector',\r\n            'punchers', 'ring_binder', 'ruler', 'scissors', 'speaker',\r\n            'stapler', 'tape_dispenser', 'trash_can']\r\n\r\nclass Office31(Dataset):\r\n    def __init__(self, root, domain='webcam', transform=None,classnames=classes):\r\n        super(Office31, self).__init__()\r\n        self.root=root\r\n        self.domain=domain\r\n        self.transform=transform\r\n        self.data_paths = []\r\n        self.data_labels = []\r\n        self.classnames=classnames\r\n        self.data_root=os.path.join(self.root, self.domain)\r\n        self.data_paths, self.data_labels = make_dataset_with_labels(self.data_root, self.classnames)\r\n        self.imgs=[]\r\n        for index in range(len(self.data_paths)):\r\n            path = self.data_paths[index]\r\n            img = Image.open(path).convert('RGB')\r\n            self.imgs.append(img)\r\n        assert(len(self.data_paths) == len(self.data_labels)), \\\r\n            'The number of images (%d) should be equal to the number of labels (%d).' % \\\r\n            (len(self.data_paths), len(self.data_labels))\r\n\r\n    def __getitem__(self, index):\r\n        img=self.imgs[index]\r\n        if self.transform is not None:\r\n            img = self.transform(img)\r\n        label = self.data_labels[index]\r\n        return img, label\r\n\r\n    def make_dataset_classwise(self, category):\r\n        imgs=[]\r\n        labels=[]\r\n        for _ in range(len(self.data_labels)):\r\n            if self.data_labels[_]==category:\r\n                imgs.append(self.imgs[_])\r\n                labels.append(self.data_labels[_])\r\n        return imgs,labels\r\n\r\n    def __len__(self):\r\n        return len(self.data_paths)\r\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Vision/VisDA.py",
    "content": "import os\r\nfrom PIL import Image\r\nfrom torch.utils.data.dataset import Dataset\r\ndef make_dataset_with_labels(dir, classnames):\r\n    images = []\r\n    labels = []\r\n    for root, _, fnames in sorted(os.walk(dir, followlinks=True)):\r\n        for fname in fnames:\r\n            dirname = os.path.split(root)[-1]\r\n            if dirname not in classnames:\r\n                continue\r\n\r\n            label = classnames.index(dirname)\r\n\r\n            path = os.path.join(root, fname)\r\n            images.append(path)\r\n            labels.append(label)\r\n    return images, labels\r\n\r\nclasses=['aeroplane',\r\n            'bicycle',\r\n            'bus',\r\n            'car',\r\n            'horse',\r\n            'knife',\r\n            'motorcycle',\r\n            'person',\r\n            'plant',\r\n            'skateboard',\r\n            'train',\r\n            'truck']\r\n\r\nclass VisDA(Dataset):\r\n    def __init__(self, root, domain='train', transform=None,classnames=classes):\r\n        super(VisDA, self).__init__()\r\n        self.root=root\r\n        self.domain=domain\r\n        self.transform=transform\r\n        self.data_paths = []\r\n        self.data_labels = []\r\n        self.data_root=os.path.join(self.root, self.domain)\r\n        self.classnames = classnames\r\n        self.data_paths, self.data_labels = make_dataset_with_labels(self.data_root, self.classnames)\r\n        '''\r\n        self.imgs=[]\r\n        for index in range(len(self.data_paths)):\r\n            path = self.data_paths[index]\r\n            img = Image.open(path).convert('RGB')\r\n            self.imgs.append(img)\r\n        # print(len(self.imgs))\r\n        # print(self.data_labels)\r\n        assert(len(self.data_paths) == len(self.data_labels)), \\\r\n            'The number of images (%d) should be equal to the number of labels (%d).' % \\\r\n            (len(self.data_paths), len(self.data_labels))\r\n        '''\r\n    def __getitem__(self, index):\r\n        #img=self.imgs[index]\r\n        path = self.data_paths[index]\r\n        img = Image.open(path).convert('RGB')\r\n        if self.transform is not None:\r\n            img = self.transform(img)\r\n        label = self.data_labels[index]\r\n        return img, label\r\n    '''\r\n    def make_dataset_classwise(self, category):\r\n        imgs=[]\r\n        labels=[]\r\n        for _ in range(len(self.data_labels)):\r\n            if self.data_labels[_]==category:\r\n                imgs.append(self.imgs[_])\r\n                labels.append(self.data_labels[_])\r\n        return imgs,labels\r\n    '''\r\n    def __len__(self):\r\n        return len(self.data_paths)\r\n"
  },
  {
    "path": "LAMDA_SSL/Dataset/Vision/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Dataset/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Distributed/DataParallel.py",
    "content": "from torch import nn\nclass DataParallel:\n    def __init__(self, device_ids=None, output_device=None, dim=0):\n        # >> Parameter\n        # >> - device_ids: Available GPUs.\n        # >> - output_device: The GPU where the output result is stored.\n        # >> - dim: The dimension of data aggregation from each device.\n        self.device_ids=device_ids\n        self.output_device=output_device\n        self.dim=dim\n    def init_parallel(self,module):\n        return nn.DataParallel(module=module,device_ids=self.device_ids,\n                               output_device=self.output_device,dim=self.dim)\n"
  },
  {
    "path": "LAMDA_SSL/Distributed/DistributedDataParallel.py",
    "content": "from torch.nn import parallel\nclass DistributedDataParallel:\n    def __init__(\n        self,\n        device_ids=None,\n        output_device=None,\n        dim=0,\n        broadcast_buffers=True,\n        process_group=None,\n        bucket_cap_mb=25,\n        find_unused_parameters=False,\n        gradient_as_bucket_view=False,\n    ):\n        # >> Parameter\n        # >> - device_ids: Available GPUs.\n        # >> - output_device: The GPU where the output result is stored.\n        # >> - dim: The dimension of data aggregation from each device.\n        # >> - broadcast_buffers: Flag that enables syncing (broadcasting) buffers of the module at beginning of the 'forward' function.\n        # >> - process_group: The process group to be used for distributed data all-reduction. If None, the default process group, which is created by :func:'torch.distributed.init_process_group', will be used.\n        # >> - bucket_cap_mb: 'DistributedDataParallel' will bucket parameters into multiple buckets so that gradient reduction of each bucket can potentially overlap with backward computation. :attr:'bucket_cap_mb' controls the bucket size in MegaBytes (MB).\n        # >> - find_unused_parameters: Traverse the autograd graph from all tensors contained in the return value of the wrapped module's 'forward' function. Parameters that don't receive gradients as part of this graph are preemptively marked as being ready to be reduced. In addition, parameters that may have been used in the wrapped module's 'forward' function but were not part of loss computation and thus would also not receive gradients are preemptively marked as ready to be reduced.\n        # >> - gradient_as_bucket_view: When set to True, gradients will be views pointing to different offsets of 'allreduce' communication buckets. This can reduce peak memory usage, where the saved memory size will be equal to the total gradients size. Moreover, it avoids the overhead of copying between gradients and 'allreduce' communication buckets. When gradients are views, detach_() cannot be called on the gradients. If hitting such errors, please fix it by referring to the :meth: '~torch.optim.Optimizer.zero_grad' function in 'torch/optim/optimizer.py' as a solution.\n        self.device_ids=device_ids\n        self.output_device=output_device\n        self.dim=dim\n        self.broadcast_buffers=broadcast_buffers\n        self.process_group=process_group\n        self.bucket_cap_mb=bucket_cap_mb\n        self.find_unused_parameters=find_unused_parameters\n        self.gradient_as_bucket_view=gradient_as_bucket_view\n    def init_parallel(self,module):\n        return parallel.DistributedDataParallel(module=module,\n                                                device_ids=self.device_ids,\n                                                output_device=self.output_device,\n                                                dim=self.dim,\n                                                broadcast_buffers=self.broadcast_buffers,\n                                                process_group=self.process_group,\n                                                bucket_cap_mb=self.bucket_cap_mb,\n                                                find_unused_parameters=self.find_unused_parameters,\n                                                gradient_as_bucket_view=self.gradient_as_bucket_view)"
  },
  {
    "path": "LAMDA_SSL/Distributed/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/AUC.py",
    "content": "from LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import roc_auc_score\nfrom LAMDA_SSL.utils import partial\nfrom LAMDA_SSL.utils import class_status\n\nclass AUC(ClassifierEvaluation):\n    def __init__(self,\n                 average=\"macro\",\n                 sample_weight=None,\n                 max_fpr=None,\n                 multi_class=\"raise\",\n                 labels=None):\n        # >> Parameter\n        # >> - average: The way to calculate the AUC mean, optional 'micro', 'macro', 'samples', 'weighted' or None.\n        # >> - sample_weight: The weight of each sample.\n        # >> - max_fpr: Used to determine the range when only a partial AUC is calculated.\n        # >> - multi_class: Method for handling multiple classes, optional 'raise', 'ovr', 'ovo'.\n        # >> - labels: The set of contained labels.\n        super().__init__()\n        self.average=average\n        self.sample_weight=sample_weight\n        self.max_fpr=max_fpr\n        self.multi_class=multi_class\n        self.labels=labels\n        self.score=partial(roc_auc_score,average=self.average,\n                           sample_weight=self.sample_weight,max_fpr=self.max_fpr,\n                           multi_class=self.multi_class,labels=self.labels)\n\n\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        num_classes=class_status(y=y_true).num_classes\n        if num_classes==2 and len(y_score.shape)==2:\n            return self.score(y_true=y_true, y_score=y_score[:,1])\n        else:\n            return self.score(y_true=y_true,y_score=y_score)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/Accuracy.py",
    "content": "from LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import accuracy_score\nfrom LAMDA_SSL.utils import partial\n\nclass Accuracy(ClassifierEvaluation):\n    def __init__(self,normalize=True, sample_weight=None):\n        # >> Parameter\n        # >> - normalize: If False, returns the number of correctly classified samples.\n        # >> - sample_weight: The weight of each sample.\n        super().__init__()\n        self.normalize=normalize\n        self.sample_weight=sample_weight\n        self.score=partial(accuracy_score,normalize=self.normalize,sample_weight=self.sample_weight)\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        # >> scoring(y_true,y_pred=None,y_score=None): Initialize the data transformation method.\n        # >> - y_true: Ground-truth labels.\n        # >> - y_pred: Hard labels for model predictions.\n        # >> - y_score: Soft labels for model predictions.\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/Confusion_Matrix.py",
    "content": "from LAMDA_SSL.utils import partial\nfrom LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import confusion_matrix\n\nclass Confusion_Matrix(ClassifierEvaluation):\n    def __init__(self,labels=None, sample_weight=None, normalize=None):\n        # >> Parameter\n        # >> - average: The way to calculate the AUC mean, optional 'micro', 'macro', 'samples', 'weighted' or None.\n        # >> - sample_weight: The weight of each sample.\n        # >> - max_fpr: Used to determine the range when only a partial AUC is calculated.\n        # >> - multi_class: Method for handling multiple classes, optional 'raise', 'ovr', 'ovo'.\n        # >> - labels: The set of contained labels.\n        super().__init__()\n        self.labels=labels\n        self.sample_weight = sample_weight\n        self.normalize = normalize\n        self.score=partial(confusion_matrix,labels=self.labels,\n                           sample_weight=self.sample_weight,\n                           normalize=self.normalize)\n\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        return self.score(y_true=y_true,y_pred=y_pred)\n\n"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/F1.py",
    "content": "from LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import f1_score\nfrom LAMDA_SSL.utils import partial\n\nclass F1(ClassifierEvaluation):\n    def __init__(self,\n                 labels=None,\n                 pos_label=1,\n                 average=\"binary\",\n                 sample_weight=None,\n                 zero_division=\"warn\"):\n        # >> Parameter\n        # >> - labels: The set of contained labels.\n        # >> - pos_label: Positive label for binary classification.\n        # >> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n        # >> - sample_weight: The weight of each sample.\n        # >> - zero_division: The return value when the denominator is 0.\n        super().__init__()\n        self.labels=labels\n        self.pos_label=pos_label\n        self.average=average\n        self.sample_weight=sample_weight\n        self.zero_division=zero_division\n        self.score=partial(f1_score,labels=self.labels,pos_label=self.pos_label,\n                           average=self.average,sample_weight=self.sample_weight,\n                           zero_division=self.zero_division)\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/Precision.py",
    "content": "from LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import precision_score\nfrom LAMDA_SSL.utils import partial\n\nclass Precision(ClassifierEvaluation):\n    def __init__(self,labels=None,\n                pos_label=1,\n                average=\"binary\",\n                sample_weight=None,\n                zero_division=\"warn\"):\n        # >> Parameter\n        # >> - labels: The set of contained labels.\n        # >> - pos_label: Positive label for binary classification.\n        # >> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n        # >> - sample_weight: The weight of each sample.\n        # >> - zero_division: The return value when the denominator is 0.\n        super().__init__()\n        self.labels=labels\n        self.pos_label=pos_label\n        self.average=average\n        self.sample_weight=sample_weight\n        self.zero_division=zero_division\n        self.score=partial(precision_score,labels=self.labels,pos_label=self.pos_label,\n                           average=self.average,sample_weight=self.sample_weight,\n                           zero_division=self.zero_division)\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/Recall.py",
    "content": "from LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import recall_score\nfrom LAMDA_SSL.utils import partial\n\nclass Recall(ClassifierEvaluation):\n    def __init__(self,\n                 labels=None,\n                 pos_label=1,\n                 average=\"binary\",\n                 sample_weight=None,\n                 zero_division=\"warn\"):\n        # >> Parameter\n        # > - labels: The set of contained labels.\n        # >> - pos_label: Positive label for binary classification.\n        # >> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n        # >> - sample_weight: The weight of each sample.\n        # >> - zero_division: The return value when the denominator is 0.\n        super().__init__()\n        self.labels=labels\n        self.pos_label=pos_label\n        self.average=average\n        self.sample_weight=sample_weight\n        self.zero_division=zero_division\n        self.score=partial(recall_score,labels=self.labels,pos_label=self.pos_label,\n                           average=self.average,sample_weight=self.sample_weight,\n                           zero_division=self.zero_division)\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/Top_k_Accuracy.py",
    "content": "from LAMDA_SSL.utils import partial\nfrom LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import top_k_accuracy_score\nfrom LAMDA_SSL.utils import class_status\n\nclass Top_k_Accurary(ClassifierEvaluation):\n    def __init__(self,k=2, normalize=True, sample_weight=None, labels=None):\n        # >> Parameter\n        # >> - k: The k value of Top_k_accurary.\n        # >> - normalize: If False, returns the number of correctly classified samples.\n        # >> - sample_weight: The weight of each sample.\n        # >> - labels: The set of contained labels.\n        super().__init__()\n        self.k=k\n        self.normalize=normalize\n        self.sample_weight=sample_weight\n        self.labels=labels\n        self.score=partial(top_k_accuracy_score,k=self.k,normalize=self.normalize,\n                           sample_weight=self.sample_weight,labels=self.labels)\n    def scoring(self,y_true,y_pred=None,y_score=None):\n        num_classes=class_status(y=y_true).num_classes\n        if num_classes==2 and len(y_score.shape)==2:\n            return self.score(y_true=y_true, y_score=y_score[:,1])\n        else:\n            return self.score(y_true=y_true,y_score=y_score)\n\n"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Classifier/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Evaluation/Cluster/Davies_Bouldin_Score.py",
    "content": "from LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\nfrom sklearn.metrics import davies_bouldin_score\n\nclass Davies_Bouldin_Score(ClusterEvaluation):\n    def __init__(self):\n        super().__init__()\n        self.score=davies_bouldin_score\n\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(labels=clusters,X=X)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Cluster/Fowlkes_Mallows_Score.py",
    "content": "from LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\nfrom sklearn.metrics import fowlkes_mallows_score\nfrom LAMDA_SSL.utils import partial\n\nclass Fowlkes_Mallows_Score(ClusterEvaluation):\n    def __init__(self,sparse=False):\n        # >> Parameter\n        # >> - sparse: Whether to use sparse matrices for computation.\n        super().__init__()\n        self.score=partial(fowlkes_mallows_score,sparse=sparse)\n\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(labels_true=y_true,labels_pred=clusters)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Cluster/Jaccard_Score.py",
    "content": "from sklearn.metrics import jaccard_score\nfrom LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\nfrom LAMDA_SSL.utils import partial\n\nclass Jaccard_Score(ClusterEvaluation):\n    def __init__(self, labels=None, pos_label=1,\n                average=\"binary\",\n                sample_weight=None,\n                zero_division=\"warn\"):\n        # >> Parameter\n        # >> - labels: The set of labels to include when ``average != 'binary'``, and their order if ``average is None``. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in ``y_true`` and ``y_pred`` are used in sorted order.\n        #\n        # >> - pos_label : The class to report if ``average='binary'`` and the data is binary. If the data are multiclass or multilabel, this will be ignored;\n        # setting ``labels=[pos_label]`` and ``average != 'binary'`` will report scores for that label only.\n        #\n        # >>- average : {'micro', 'macro', 'samples', 'weighted', 'binary'} or None. If ``None``, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data:\n        #     ``'binary'``:\n        #         Only report results for the class specified by ``pos_label``.\n        #         This is applicable only if targets (``y_{true,pred}``) are binary.\n        #     ``'micro'``:\n        #         Calculate metrics globally by counting the total true positives,\n        #         false negatives and false positives.\n        #     ``'macro'``:\n        #         Calculate metrics for each label, and find their unweighted\n        #         mean.  This does not take label imbalance into account.\n        #     ``'weighted'``:\n        #         Calculate metrics for each label, and find their average, weighted\n        #         by support (the number of true instances for each label). This\n        #         alters 'macro' to account for label imbalance.\n        #     ``'samples'``:\n        #         Calculate metrics for each instance, and find their average (only\n        #         meaningful for multilabel classification).\n        #\n        # >> - sample_weight : array-like of shape (n_samples,), Sample weights.\n        #\n        # >> - zero_division : \"warn\", {0.0, 1.0}, default=\"warn\" Sets the value to return when there is a zero division, i.e. when there are no negative values in predictions and labels. If set to \"warn\", this acts like 0, but a warning is also raised.\n        super().__init__()\n        self.score=partial(jaccard_score,labels=labels,\n        pos_label=pos_label,\n        average=average,\n        sample_weight=sample_weight,\n        zero_division=zero_division)\n\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(y_true=y_true,y_pred=clusters)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Cluster/Rand_Score.py",
    "content": "from sklearn.metrics import rand_score\nfrom LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\n\nclass Rand_Score(ClusterEvaluation):\n    def __init__(self):\n        super().__init__()\n        self.score=rand_score\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(labels_true=y_true,labels_pred=clusters)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Cluster/Silhouette_Score.py",
    "content": "from sklearn.metrics import silhouette_score\nfrom LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\nfrom LAMDA_SSL.utils import partial\n\nclass Silhouette_Score(ClusterEvaluation):\n    def __init__(self, metric=\"euclidean\", sample_size=None, random_state=None):\n        # >> Parameter\n        # >> - metric : The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options allowed by <sklearn.metrics.pairwise.pairwise_distances>. If ``X`` of the `scoring` method is the distance array itself, use ``metric=\"precomputed\"``.\n        # >> - sample_size: The size of the sample to use when computing the Silhouette Coefficient on a random subset of the data.\n        # >> - random_state : Determines random number generation for selecting a subset of samples.\n        super().__init__()\n        self.score=partial(silhouette_score, metric=metric, sample_size=sample_size, random_state=random_state)\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(labels=clusters,X=X)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Cluster/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Evaluation/Regressor/Mean_Absolute_Error.py",
    "content": "from LAMDA_SSL.Base.RegressorEvaluation import RegressorEvaluation\nfrom sklearn.metrics import mean_absolute_error\nfrom LAMDA_SSL.utils import partial\n\nclass Mean_Absolute_Error(RegressorEvaluation):\n    def __init__(self,sample_weight=None, multioutput=\"uniform_average\"):\n        # >> Parameter\n        # >> - sample_weight: The weight of each sample.\n        # >> - multioutput: Aggregation method for multiple outputs.\n        super().__init__()\n        self.sample_weight=sample_weight\n        self.multioutput=multioutput\n        self.score=partial(mean_absolute_error,sample_weight=self.sample_weight,multioutput=self.multioutput)\n    def scoring(self,y_true,y_pred=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Regressor/Mean_Squared_Error.py",
    "content": "from LAMDA_SSL.Base.RegressorEvaluation import RegressorEvaluation\nfrom sklearn.metrics import mean_squared_error\nfrom LAMDA_SSL.utils import partial\n\nclass Mean_Squared_Error(RegressorEvaluation):\n    def __init__(self,sample_weight=None, multioutput=\"uniform_average\",squared=True):\n        # >> Parameter\n        # >> - sample_weight: The weight of each sample.\n        # >> - multioutput: Aggregation method for multiple outputs.\n        # >> - squared: If True, output the MSE loss, otherwise output the RMSE loss.\n        super().__init__()\n        self.sample_weight=sample_weight\n        self.multioutput=multioutput\n        self.squared=squared\n        self.score=partial(mean_squared_error,sample_weight=self.sample_weight,\n                           multioutput=self.multioutput,squared=squared)\n    def scoring(self,y_true,y_pred=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Regressor/Mean_Squared_Log_Error.py",
    "content": "from LAMDA_SSL.Base.RegressorEvaluation import RegressorEvaluation\nfrom sklearn.metrics import mean_squared_log_error\nfrom LAMDA_SSL.utils import partial\n\nclass Mean_Squared_Log_Error(RegressorEvaluation):\n    def __init__(self,sample_weight=None, multioutput=\"uniform_average\",squared=True):\n        # >> Parameter\n        # >> - sample_weight: The weight of each sample.\n        # >> - multioutput: Aggregation method for multiple outputs.\n        # >> - squared: If True, output the MSLE loss, otherwise output the RMSLE loss.\n        super().__init__()\n        self.sample_weight=sample_weight\n        self.multioutput=multioutput\n        self.score=partial(mean_squared_log_error,sample_weight=self.sample_weight,\n                           multioutput=self.multioutput,squared=squared)\n    def scoring(self,y_true,y_pred=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Regressor/Median_Absolute_Error.py",
    "content": "from LAMDA_SSL.Base.RegressorEvaluation import RegressorEvaluation\nfrom sklearn.metrics import median_absolute_error\nfrom LAMDA_SSL.utils import partial\n\nclass Median_Absolute_Error(RegressorEvaluation):\n    def __init__(self,sample_weight=None, multioutput=\"uniform_average\"):\n        # >> Parameter\n        # >> - sample_weight: The weight of each sample.\n        # >> - multioutput: Aggregation method for multiple outputs.\n        super().__init__()\n        self.sample_weight=sample_weight\n        self.multioutput=multioutput\n        self.score=partial(median_absolute_error,sample_weight=self.sample_weight,multioutput=self.multioutput)\n    def scoring(self,y_true,y_pred=None):\n        return self.score(y_true=y_true,y_pred=y_pred)"
  },
  {
    "path": "LAMDA_SSL/Evaluation/Regressor/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Evaluation/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Loss/Consistency.py",
    "content": "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch\n\nclass Consistency(nn.Module):\n    def __init__(self,reduction='mean'):\n        # >> Parameter\n        # >> - reduction: How to handle the output.\n        super().__init__()\n        self.reduction = reduction\n\n    def forward(self,logits_1,logits_2):\n        # >> forward(logits_1,logits_2): Perform loss calculations.\n        # >> - logits_1: The first input to compute consistency.\n        # >> - logits_2: The second input to compute consistency.\n        assert logits_1.size() == logits_2.size()\n        return F.mse_loss(torch.softmax(logits_1, dim=-1), torch.softmax(logits_2, dim=-1), reduction=self.reduction)"
  },
  {
    "path": "LAMDA_SSL/Loss/Cross_Entropy.py",
    "content": "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch\nclass Cross_Entropy(nn.Module):\n    def __init__(self, use_hard_labels=True, reduction='mean'):\n        # >> Parameter\n        # >> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n        # >> - reduction: How to handle the output.\n        super(Cross_Entropy, self).__init__()\n        self.use_hard_labels=use_hard_labels\n        self.reduction=reduction\n\n    def forward(self,logits, targets):\n        # >> - logits: The output of the model.\n        # >> - targets: The target result.\n        targets=targets.long()\n        if self.use_hard_labels:\n            log_pred = F.log_softmax(logits, dim=-1)\n            return F.nll_loss(log_pred, targets, reduction=self.reduction)\n        else:\n            log_pred = F.log_softmax(logits, dim=-1)\n            nll_loss = torch.sum(-targets * log_pred, dim=1)\n            if self.reduction=='mean':\n                nll_loss=nll_loss.mean()\n            elif self.reduction=='sum':\n                nll_loss=nll_loss.sum()\n            return nll_loss"
  },
  {
    "path": "LAMDA_SSL/Loss/EntMin.py",
    "content": "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch\nclass EntMin(nn.Module):\n    def __init__(self, reduction='mean', activation=None):\n        # >> - reduction: How to handle the output.\n        # >> - activation: The activation function to process on the logits.\n        super(EntMin, self).__init__()\n        self.activation=activation\n        self.reduction=reduction\n\n    def forward(self,logits):\n        # >> -logits: The logits to calculate the loss.\n        if self.activation is not None:\n            p=self.activation(logits)\n        else:\n            p=logits\n        log_pred = F.log_softmax(logits, dim=-1)\n        loss = torch.sum(-p * log_pred, dim=-1)\n        if self.reduction=='mean':\n            loss=loss.mean()\n        elif self.reduction=='sum':\n            loss=loss.sum()\n        return loss"
  },
  {
    "path": "LAMDA_SSL/Loss/KL_Divergence.py",
    "content": "import torch.nn as nn\nimport torch.nn.functional as F\nimport torch\nclass KL_Divergence(nn.Module):\n    def __init__(self,softmax_1=True,softmax_2=True,reduction='mean'):\n        # >> - softmax_1: Whether to softmax the first input.\n        # >> - softmax_2: Whether to softmax the second input.\n        # >> - reduction: How to handle the output.\n        super(KL_Divergence, self).__init__()\n        self.softmax_1=softmax_1\n        self.softmax_2=softmax_2\n        self.reduction=reduction\n\n    def forward(self,logits_1,logits_2): # KL(p||q)\n        # >> forward(logits_1,logits_2): Perform loss calculations.\n        # >> - logits_1: The first input to compute consistency.\n        # >> - logits_2: The second input to compute consistency.\n        if self.softmax_1:\n            p = F.softmax(logits_1, dim=1)\n            logp = F.log_softmax(logits_1, dim=1)\n        else:\n            p=logits_1\n            logp=torch.log(p)\n\n        if self.softmax_2:\n            logq = F.log_softmax(logits_2, dim=1)\n        else:\n            logq=torch.log(logits_2)\n\n        plogp = ( p *logp).sum(dim=1)\n        plogq = ( p *logq).sum(dim=1)\n        kl_div=plogp - plogq\n        if self.reduction=='mean':\n            kl_div=kl_div.mean()\n        elif self.reduction=='sum':\n            kl_div=kl_div.sum()\n        return kl_div"
  },
  {
    "path": "LAMDA_SSL/Loss/MSE.py",
    "content": "import torch.nn as nn\nimport torch.nn.functional as F\n\nclass MSE(nn.Module):\n    def __init__(self,reduction='mean',activation_1=None,activation_2=None):\n        super().__init__()\n        # >> Parameter\n        # >> - reduction: How to handle the output.\n        # >> - activation_1: The activation function to process on the first input.\n        # >> - activation_2: The activation function to process on the second input.\n        self.reduction = reduction\n        self.activation_1=activation_1\n        self.activation_2=activation_2\n    def forward(self,logits_1,logits_2):\n        # >> forward(logits_1,logits_2): Perform loss calculations.\n        # >> - logits_1: The first input to compute consistency.\n        # >> - logits_2: The second input to compute consistency.\n        if self.activation_1 is not None:\n            logits_1=self.activation_1(logits_1)\n        if self.activation_2 is not None:\n            logits_2=self.activation_2(logits_2)\n        return F.mse_loss(logits_1, logits_2, reduction=self.reduction)"
  },
  {
    "path": "LAMDA_SSL/Loss/Semi_Supervised_Loss.py",
    "content": "import torch.nn as nn\nclass Semi_Supervised_Loss(nn.Module):\n    def __init__(self,lambda_u=1.0):\n        # lambda_u: The weight of unsupervised loss.\n        super().__init__()\n        self.lambda_u=lambda_u\n    def forward(self,sup_loss,unsup_loss):\n        # sup_loss: The supervised loss.\n        # unsup_loss: The unsupervised loss.\n        return sup_loss+self.lambda_u*unsup_loss"
  },
  {
    "path": "LAMDA_SSL/Loss/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Network/AdversarialNet.py",
    "content": "import torch\nimport torch.nn as nn\nimport numpy as np\nclass GradientReverseLayer(torch.autograd.Function):\n    \"\"\"\n    usage:(can't be used in nn.Sequential, not a subclass of nn.Module)::\n\n        x = Variable(torch.ones(1, 2), requires_grad=True)\n        grl = GradientReverseLayer.apply\n        y = grl(0.5, x)\n\n        y.backward(torch.ones_like(y))\n\n        print(x.grad)\n\n    \"\"\"\n    @staticmethod\n    def forward(ctx, coeff, input):\n        ctx.coeff = coeff\n        # this is necessary. if we just return ``input``, ``backward`` will not be called sometimes\n        return input.view_as(input)\n\n    @staticmethod\n    def backward(ctx, grad_outputs):\n        coeff = ctx.coeff\n        return None, -coeff * grad_outputs\n\n\nclass GradientReverseModule(nn.Module):\n\n\n    def __init__(self, scheduler):\n        super(GradientReverseModule, self).__init__()\n        self.scheduler = scheduler\n        self.register_buffer('global_step', torch.zeros(1))\n        self.coeff = 0.0\n        self.grl = GradientReverseLayer.apply\n\n    def forward(self, x):\n        self.coeff = self.scheduler(self.global_step.item())\n        if self.training:\n            self.global_step += 1.0\n        return self.grl(self.coeff, x)\n\ndef aToBSheduler(step, A, B, gamma=10, max_iter=10000):\n    ans = A + (2.0 / (1 + np.exp(- gamma * step * 1.0 / max_iter)) - 1.0) * (B - A)\n    return float(ans)\n\nclass AdversarialNet(nn.Module):\n    def __init__(self, in_feature):\n        super(AdversarialNet, self).__init__()\n        self.main = nn.Sequential(\n            nn.Linear(in_feature, 16),\n            nn.ReLU(inplace=True),\n            nn.Dropout(0.5),\n            nn.Linear(16,16),\n            nn.ReLU(inplace=True),\n            nn.Dropout(0.5),\n            nn.Linear(16, 1),\n            nn.Sigmoid()\n        )\n        self.grl = GradientReverseModule(lambda step: aToBSheduler(step, 0.0, 1.0, gamma=10, max_iter=100000))\n\n    def forward(self, x):\n        x_ = self.grl(x)\n        y = self.main(x_)\n        return y"
  },
  {
    "path": "LAMDA_SSL/Network/FT_Transformer.py",
    "content": "import math\nimport typing as ty\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.nn.init as nn_init\n\nfrom torch import Tensor\n\nclass Tokenizer(nn.Module):\n    category_offsets: ty.Optional[Tensor]\n\n    def __init__(\n        self,\n        d_numerical: int,\n        categories: ty.Optional[ty.List[int]],\n        d_token: int,\n        bias: bool,\n    ) -> None:\n        #categories = None\n        super().__init__()\n        if categories is None:\n            d_bias = d_numerical\n            self.category_offsets = None\n            self.category_embeddings = None\n        else:\n            d_bias = d_numerical + len(categories)\n            category_offsets = torch.tensor([0] + categories[:-1]).cumsum(0)\n            self.register_buffer('category_offsets', category_offsets)\n            self.category_embeddings = nn.Embedding(sum(categories), d_token)\n            nn_init.kaiming_uniform_(self.category_embeddings.weight, a=math.sqrt(5))\n            print(f'{self.category_embeddings.weight.shape}=')\n\n        # take [CLS] token into account\n        self.weight = nn.Parameter(Tensor(d_numerical + 1, d_token))\n        self.bias = nn.Parameter(Tensor(d_bias, d_token)) if bias else None\n        # The initialization is inspired by nn.Linear\n        nn_init.kaiming_uniform_(self.weight, a=math.sqrt(5))\n        if self.bias is not None:\n            nn_init.kaiming_uniform_(self.bias, a=math.sqrt(5))\n\n    @property\n    def n_tokens(self) -> int:\n        return len(self.weight) + (\n            0 if self.category_offsets is None else len(self.category_offsets)\n        )\n\n    def forward(self, x_num: Tensor, x_cat: ty.Optional[Tensor]) -> Tensor:\n        x_some = x_num if x_cat is None else x_cat\n        assert x_some is not None\n        x_num = torch.cat(\n            [torch.ones(len(x_some), 1, device=x_some.device)]  # [CLS]\n            + ([] if x_num is None else [x_num]),\n            dim=1,\n        )\n        x = self.weight[None] * x_num[:, :, None]\n        if x_cat is not None:\n            x = torch.cat(\n                [x, self.category_embeddings(x_cat + self.category_offsets[None])],\n                dim=1,\n            )\n        if self.bias is not None:\n            bias = torch.cat(\n                [\n                    torch.zeros(1, self.bias.shape[1], device=x.device),\n                    self.bias,\n                ]\n            )\n            x = x + bias[None]\n        return x\n\n\nclass MultiheadAttention(nn.Module):\n    def __init__(\n        self, d: int, n_heads: int, dropout: float, initialization: str\n    ) -> None:\n        if n_heads > 1:\n            assert d % n_heads == 0\n        assert initialization in ['xavier', 'kaiming']\n\n        super().__init__()\n        self.W_q = nn.Linear(d, d)\n        self.W_k = nn.Linear(d, d)\n        self.W_v = nn.Linear(d, d)\n        self.W_out = nn.Linear(d, d) if n_heads > 1 else None\n        self.n_heads = n_heads\n        self.dropout = nn.Dropout(dropout) if dropout else None\n\n        for m in [self.W_q, self.W_k, self.W_v]:\n            if initialization == 'xavier' and (n_heads > 1 or m is not self.W_v):\n                # gain is needed since W_qkv is represented with 3 separate layers\n                nn_init.xavier_uniform_(m.weight, gain=1 / math.sqrt(2))\n            nn_init.zeros_(m.bias)\n        if self.W_out is not None:\n            nn_init.zeros_(self.W_out.bias)\n\n    def _reshape(self, x: Tensor) -> Tensor:\n        batch_size, n_tokens, d = x.shape\n        d_head = d // self.n_heads\n        return (\n            x.reshape(batch_size, n_tokens, self.n_heads, d_head)\n            .transpose(1, 2)\n            .reshape(batch_size * self.n_heads, n_tokens, d_head)\n        )\n\n    def forward(\n        self,\n        x_q: Tensor,\n        x_kv: Tensor,\n        key_compression: ty.Optional[nn.Linear],\n        value_compression: ty.Optional[nn.Linear],\n    ) -> Tensor:\n        q, k, v = self.W_q(x_q), self.W_k(x_kv), self.W_v(x_kv)\n        for tensor in [q, k, v]:\n            assert tensor.shape[-1] % self.n_heads == 0\n        if key_compression is not None:\n            assert value_compression is not None\n            k = key_compression(k.transpose(1, 2)).transpose(1, 2)\n            v = value_compression(v.transpose(1, 2)).transpose(1, 2)\n        else:\n            assert value_compression is None\n\n        batch_size = len(q)\n        d_head_key = k.shape[-1] // self.n_heads\n        d_head_value = v.shape[-1] // self.n_heads\n        n_q_tokens = q.shape[1]\n\n        q = self._reshape(q)\n        k = self._reshape(k)\n        attention = F.softmax(q @ k.transpose(1, 2) / math.sqrt(d_head_key), dim=-1)\n        if self.dropout is not None:\n            attention = self.dropout(attention)\n        x = attention @ self._reshape(v)\n        x = (\n            x.reshape(batch_size, self.n_heads, n_q_tokens, d_head_value)\n            .transpose(1, 2)\n            .reshape(batch_size, n_q_tokens, self.n_heads * d_head_value)\n        )\n        if self.W_out is not None:\n            x = self.W_out(x)\n        return x\n\n\nclass FT_Transformer(nn.Module):\n    def __init__(\n        self,\n        # tokenizer\n        dim_in: int,\n        categories=None,\n        token_bias=True,\n        # transformer\n        num_layers=8,\n        dim_token=192,\n        num_heads=8,\n        d_ffn_factor= 4/3,\n        attention_dropout=0.2,\n        ffn_dropout=0.1,\n        residual_dropout=0,\n        activation='reglu',\n        prenormalization=True,\n        initialization='kaiming',\n        # linformer\n        kv_compression=True,\n        kv_compression_sharing='headwise',\n        #\n        num_classes=1,\n        regression=False,\n        categorical_indicator=None\n    ) -> None:\n        assert (kv_compression is None) ^ (kv_compression_sharing is not None)\n        super().__init__()\n        self.tokenizer = Tokenizer(dim_in, categories, dim_token, token_bias)\n        n_tokens = self.tokenizer.n_tokens\n\n        self.categorical_indicator = categorical_indicator\n        self.regression = regression\n\n        def make_kv_compression():\n            assert kv_compression\n            compression = nn.Linear(\n                n_tokens, int(n_tokens * kv_compression), bias=False\n            )\n            if initialization == 'xavier':\n                nn_init.xavier_uniform_(compression.weight)\n            return compression\n\n        self.shared_kv_compression = (\n            make_kv_compression()\n            if kv_compression and kv_compression_sharing == 'layerwise'\n            else None\n        )\n\n        def make_normalization():\n            return nn.LayerNorm(dim_token)\n\n        d_hidden = int(dim_token * d_ffn_factor)\n        self.layers = nn.ModuleList([])\n        for layer_idx in range(num_layers):\n            layer = nn.ModuleDict(\n                {\n                    'attention': MultiheadAttention(\n                        dim_token, num_heads, attention_dropout, initialization\n                    ),\n                    'linear0': nn.Linear(\n                        dim_token, d_hidden * (2 if activation.endswith('glu') else 1)\n                    ),\n                    'linear1': nn.Linear(d_hidden, dim_token),\n                    'norm1': make_normalization(),\n                }\n            )\n            if not prenormalization or layer_idx:\n                layer['norm0'] = make_normalization()\n            if kv_compression and self.shared_kv_compression is None:\n                layer['key_compression'] = make_kv_compression()\n                if kv_compression_sharing == 'headwise':\n                    layer['value_compression'] = make_kv_compression()\n                else:\n                    assert kv_compression_sharing == 'key-value'\n            self.layers.append(layer)\n\n        def reglu(x: Tensor) -> Tensor:\n            a, b = x.chunk(2, dim=-1)\n            return a * F.relu(b)\n\n        def geglu(x: Tensor) -> Tensor:\n            a, b = x.chunk(2, dim=-1)\n            return a * F.gelu(b)\n\n        def get_nonglu_activation_fn(name: str) -> ty.Callable[[Tensor], Tensor]:\n            return (\n                F.relu\n                if name == 'reglu'\n                else F.gelu\n                if name == 'geglu'\n                else get_activation_fn(name)\n            )\n        def get_activation_fn(name: str) -> ty.Callable[[Tensor], Tensor]:\n            return (\n                reglu\n                if name == 'reglu'\n                else geglu\n                if name == 'geglu'\n                else torch.sigmoid\n                if name == 'sigmoid'\n                else getattr(F, name)\n            )\n        self.activation = get_activation_fn(activation)\n        self.last_activation = get_nonglu_activation_fn(activation)\n        self.prenormalization = prenormalization\n        self.last_normalization = make_normalization() if prenormalization else None\n        self.ffn_dropout = ffn_dropout\n        self.residual_dropout = residual_dropout\n        self.head = nn.Linear(dim_token, num_classes)\n\n    def _get_kv_compressions(self, layer):\n        return (\n            (self.shared_kv_compression, self.shared_kv_compression)\n            if self.shared_kv_compression is not None\n            else (layer['key_compression'], layer['value_compression'])\n            if 'key_compression' in layer and 'value_compression' in layer\n            else (layer['key_compression'], layer['key_compression'])\n            if 'key_compression' in layer\n            else (None, None)\n        )\n\n    def _start_residual(self, x, layer, norm_idx):\n        x_residual = x\n        if self.prenormalization:\n            norm_key = f'norm{norm_idx}'\n            if norm_key in layer:\n                x_residual = layer[norm_key](x_residual)\n        return x_residual\n\n    def _end_residual(self, x, x_residual, layer, norm_idx):\n        if self.residual_dropout:\n            x_residual = F.dropout(x_residual, self.residual_dropout, self.training)\n        x = x + x_residual\n        if not self.prenormalization:\n            x = layer[f'norm{norm_idx}'](x)\n        return x\n\n    def forward(self, x) -> Tensor:\n        if not self.categorical_indicator is None:\n            x_num = x[:, ~self.categorical_indicator].float()\n            x_cat = x[:, self.categorical_indicator].long() #TODO\n        else:\n            x_num = x\n            x_cat = None\n        #x_cat = None #FIXME\n        x = self.tokenizer(x_num, x_cat)\n\n        for layer_idx, layer in enumerate(self.layers):\n            is_last_layer = layer_idx + 1 == len(self.layers)\n            layer = ty.cast(ty.Dict[str, nn.Module], layer)\n\n            x_residual = self._start_residual(x, layer, 0)\n            x_residual = layer['attention'](\n                # for the last attention, it is enough to process only [CLS]\n                (x_residual[:, :1] if is_last_layer else x_residual),\n                x_residual,\n                *self._get_kv_compressions(layer),\n            )\n            if is_last_layer:\n                x = x[:, : x_residual.shape[1]]\n            x = self._end_residual(x, x_residual, layer, 0)\n\n            x_residual = self._start_residual(x, layer, 1)\n            x_residual = layer['linear0'](x_residual)\n            x_residual = self.activation(x_residual)\n            if self.ffn_dropout:\n                x_residual = F.dropout(x_residual, self.ffn_dropout, self.training)\n            x_residual = layer['linear1'](x_residual)\n            x = self._end_residual(x, x_residual, layer, 1)\n\n        assert x.shape[1] == 1\n        x = x[:, 0]\n        if self.last_normalization is not None:\n            x = self.last_normalization(x)\n        x = self.last_activation(x)\n        x = self.head(x)\n        if not self.regression:\n            x = x.squeeze(-1)\n        return x"
  },
  {
    "path": "LAMDA_SSL/Network/GAT.py",
    "content": "import torch\nfrom torch_geometric.nn import  GATConv\nimport torch.nn.functional as F\n\nclass GAT(torch.nn.Module):\n    def __init__(self, dim_in, num_classes, dim_hidden=16,  heads=8, dropout=0.6):\n        # >> Parameter:\n        # >> - dim_in: Node feature dimension.\n        # >> - dim_hidden: the dimension of hidden layers.\n        # >> - num_classes: Number of classes.\n        # >> - dropout: The dropout rate.\n        # >> - heads: The number of heads.\n        super().__init__()\n        self.dropout=dropout\n        self.conv1 = GATConv(dim_in, dim_hidden, heads, dropout=dropout)\n        self.conv2 = GATConv(dim_hidden * heads, num_classes, heads=1,\n                             concat=False, dropout=dropout)\n\n    def forward(self, data):\n        x,edge_index=data.x,data.edge_index\n        x = F.dropout(x, p=self.dropout, training=self.training)\n        x = F.elu(self.conv1(x, edge_index))\n        x = F.dropout(x, p=self.dropout, training=self.training)\n        x = self.conv2(x, edge_index)\n        return x\n"
  },
  {
    "path": "LAMDA_SSL/Network/GCN.py",
    "content": "import torch\nfrom torch_geometric.nn import  GCNConv\nimport torch.nn.functional as F\nclass GCN(torch.nn.Module):\n    def __init__(self,dim_in,num_classes,dim_hidden=16,normalize=False):\n        # >> Parameter\n        # >> - dim_in: The number of features.\n        # >> - num_classes: The number of classes.\n        # >> - normalize: Whether to add self-loops and compute symmetric normalization coefficients on the fly.\n        super().__init__()\n        self.conv1 = GCNConv(dim_in, dim_hidden, cached=True,\n                             normalize=normalize)\n        self.conv2 = GCNConv(dim_hidden, num_classes, cached=True,\n                             normalize=normalize)\n\n    def forward(self,data):\n        x, edge_index, edge_weight = data.x, data.edge_index, data.edge_attr\n        x = F.relu(self.conv1(x, edge_index, edge_weight))\n        x = F.dropout(x, training=self.training)\n        x = self.conv2(x, edge_index, edge_weight)\n        return x"
  },
  {
    "path": "LAMDA_SSL/Network/ImprovedGAN.py",
    "content": "import numbers\n\nimport torch\nfrom torch.nn.parameter import Parameter\nfrom torch import nn\nfrom torch.nn import functional as F\nfrom torch.autograd import Variable\n\nclass LinearWeightNorm(torch.nn.Module):\n    def __init__(self, in_features, out_features, bias=True, weight_scale=None, weight_init_stdv=0.1):\n        super(LinearWeightNorm, self).__init__()\n        self.in_features = in_features\n        self.out_features = out_features\n        self.weight = Parameter(torch.randn(out_features, in_features) * weight_init_stdv)\n        if bias:\n            self.bias = Parameter(torch.zeros(out_features))\n        else:\n            self.register_parameter('bias', None)\n        if weight_scale is not None:\n            assert type(weight_scale) == int\n            self.weight_scale = Parameter(torch.ones(out_features, 1) * weight_scale)\n        else:\n            self.weight_scale = 1\n    def forward(self, x):\n        W = self.weight * self.weight_scale / torch.sqrt(torch.sum(self.weight ** 2, dim = 1, keepdim = True))\n        return F.linear(x, W, self.bias)\n\nclass Discriminator(nn.Module):\n    def __init__(self, dim_in = 28 ** 2,hidden_dim=[1000,500,250,250,250],\n                 noise_level=[0.3,0.5,0.5,0.5,0.5,0.5],activations=[nn.ReLU(),nn.ReLU(),nn.ReLU(),nn.ReLU(),nn.ReLU()],\n                 dim_out = 10,device='cpu'):\n        super(Discriminator, self).__init__()\n        self.dim_in = dim_in\n        self.num_hidden=len(hidden_dim)\n        self.layers = torch.nn.ModuleList()\n        self.noise_level=noise_level\n        for _ in range(self.num_hidden):\n            if _==0:\n                input_dim=dim_in\n            else:\n                input_dim=hidden_dim[_-1]\n            out_dim=hidden_dim[_]\n            self.layers.append(LinearWeightNorm(input_dim, out_dim))\n        self.final = LinearWeightNorm(hidden_dim[self.num_hidden-1], dim_out, weight_scale=1)\n        self.activations=activations\n        self.device=device\n\n\n    def forward(self, x):\n        x = x.view(-1, self.dim_in)\n        noise = torch.randn(x.size()).to(self.device) * self.noise_level[0] if self.training else torch.Tensor([0]).to(self.device)\n\n        x = x + Variable(noise, requires_grad = False)\n        x_f=x\n        for i in range(len(self.layers)):\n            m = self.layers[i]\n            x_f = self.activations[i](m(x))\n            noise = torch.randn(x_f.size()).to(self.device) * self.noise_level[i+1] if self.training else torch.Tensor([0]).to(self.device)\n            x = (x_f + Variable(noise, requires_grad = False))\n\n        self.feature=x_f\n        if len(self.activations)==self.num_hidden+1:\n            x = self.activations[self.num_hidden](self.final(x))\n        else:\n            x=self.final(x)\n        return x\n\n\nclass Generator(nn.Module):\n    def __init__(self, dim_in = 28 ** 2,hidden_dim=[500,500],activations=[nn.Softplus(),nn.Softplus(),nn.Softplus()],dim_z=100,device='cpu'):\n        super(Generator, self).__init__()\n        self.dim_z = dim_z\n        self.device=device\n        self.hidden_dim=hidden_dim\n        self.layers = torch.nn.ModuleList()\n        self.bn_layers=torch.nn.ModuleList()\n        self.bn_b = torch.nn.ParameterList()\n        self.num_hidden=len(hidden_dim)\n        self.activations=activations\n        for _ in range(self.num_hidden):\n            if _==0:\n                input_dim=dim_z\n            else:\n                input_dim=hidden_dim[_-1]\n            output_dim=hidden_dim[_]\n            fc=nn.Linear(input_dim, output_dim, bias=False)\n            nn.init.xavier_uniform(fc.weight)\n            self.layers.append(fc)\n            self.bn_layers.append(nn.BatchNorm1d(output_dim, affine = False, eps=1e-6, momentum = 0.5))\n            self.bn_b.append(Parameter(torch.zeros(output_dim)))\n        self.fc = LinearWeightNorm(hidden_dim[self.num_hidden-1], dim_in, weight_scale = 1)\n\n\n    def forward(self, batch_size=10,z=None):\n        z = Variable(torch.rand(batch_size, self.dim_z), requires_grad = False,volatile = not self.training).to(self.device) if z is None else z\n        for _ in range(self.num_hidden):\n            z = self.activations[_](self.bn_layers[_](self.layers[_](z)) + self.bn_b[_])\n        if len(self.activations)==self.num_hidden+1:\n            z = self.activations[self.num_hidden](self.fc(z))\n        else:\n            z=self.fc(z)\n        return z\n\nclass ImprovedGAN(nn.Module):\n    def __init__(self, G=None, D=None,dim_in = 28 ** 2,\n                 hidden_G=[1000,500,250,250,250],\n                 hidden_D=[1000,500,250,250,250],\n                 noise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5],\n                 activations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus(),nn.Softplus(), nn.Softplus(), nn.Softplus()],\n                 activations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 dim_out = 10,dim_z=100,device='cpu'):\n        # >> Parameter\n        # >> - G: The neural network of generator.\n        # >> - D: The neural network of discriminator\n        # >> - dim_in: The dimension of the inputted samples.\n        # >> - hidden_G: The dimension of the generator's hidden layers.\n        # >> - hidden_D: The dimension of the discriminator's hidden layers.\n        # >> - activations_G: The activation functions for each layer of the generator.\n        # >> - activations_D: The activation functions for each layer of the discriminator.\n        # >> - output_dim: The dimension of outputs.\n        # >> - z_dim: The dimension of the hidden variable used to generate data.\n        # >> - device: The device to train the model.\n        super(ImprovedGAN, self).__init__()\n        if isinstance(dim_in,numbers.Number):\n            input_dim = dim_in\n        else:\n            input_dim=1\n            for item in dim_in:\n                input_dim=input_dim*item\n        self.G = G if G is not None else Generator(dim_in = input_dim,dim_z=dim_z,\n                                                   hidden_dim=hidden_G,activations=activations_G,\n                                                   device=device)\n        self.D = D if D is not None else Discriminator(dim_in=input_dim,noise_level=noise_level,\n                                                       activations=activations_D,dim_out=dim_out,\n                                                       hidden_dim=hidden_D,device=device)\n\n    def forward(self, x):\n        return self.D(x)\n"
  },
  {
    "path": "LAMDA_SSL/Network/LadderNetwork.py",
    "content": "import numbers\n\nimport torch\nimport numpy as np\nfrom torch.nn.parameter import Parameter\nfrom torch.autograd import Variable\nimport torch.nn as nn\n\nclass Encoder(torch.nn.Module):\n    def __init__(self, dim_in, dim_out, activation,\n                 train_bn_scaling, noise_level,device='cpu'):\n        super(Encoder, self).__init__()\n        self.dim_in=dim_in\n        self.dim_out = dim_out\n        self.activation = activation\n        self.train_bn_scaling = train_bn_scaling\n        self.noise_level = noise_level\n        self.device=device\n\n        # Encoder\n        # Encoder only uses W matrix, no bias\n        self.linear = torch.nn.Linear(dim_in, dim_out, bias=False)\n        self.linear.weight.data = torch.randn(self.linear.weight.data.size()) / np.sqrt(dim_in)\n\n        # Batch Normalization\n        # For Relu Beta of batch-norm is redundant, hence only Gamma is trained\n        # For Softmax Beta, Gamma are trained\n        # batch-normalization bias\n        self.bn_normalize_clean = torch.nn.BatchNorm1d(dim_out, affine=False)\n        self.bn_normalize = torch.nn.BatchNorm1d(dim_out, affine=False)\n        self.bn_beta = Parameter(torch.FloatTensor(1, dim_out).to(self.device))\n        self.bn_beta.data.zero_()\n        if self.train_bn_scaling:\n            self.bn_gamma = Parameter(torch.FloatTensor(1, dim_out).to(self.device))\n            self.bn_gamma.data = torch.ones(self.bn_gamma.size()).to(self.device)\n\n        # Activation\n\n        # buffer for z_pre, z which will be used in decoder cost\n        self.buffer_z_pre = None\n        self.buffer_z = None\n        # buffer for tilde_z which will be used by decoder for reconstruction\n        self.buffer_tilde_z = None\n\n    def bn_gamma_beta(self, x):\n\n        ones = Parameter(torch.ones(x.size()[0], 1).to(self.device))\n        t = x + ones.mm(self.bn_beta)\n        if self.train_bn_scaling:\n            t = torch.mul(t, ones.mm(self.bn_gamma))\n        return t\n\n    def forward_clean(self, h):\n        z_pre = self.linear(h)\n        # Store z_pre, z to be used in calculation of reconstruction cost\n        self.buffer_z_pre = z_pre.detach().clone()\n        z = self.bn_normalize_clean(z_pre)\n        self.buffer_z = z.detach().clone()\n        z_gb = self.bn_gamma_beta(z)\n        if self.activation is None:\n            h=z_gb\n        else:\n            h = self.activation(z_gb)\n        return h\n\n    def forward_noise(self, tilde_h):\n        # z_pre will be used in the decoder cost\n        z_pre = self.linear(tilde_h)\n        z_pre_norm = self.bn_normalize(z_pre)\n        # Add noise\n        noise = np.random.normal(loc=0.0, scale=self.noise_level, size=z_pre_norm.size())\n\n        noise = Variable(torch.FloatTensor(noise).to(self.device))\n        # tilde_z will be used by decoder for reconstruction\n        tilde_z = z_pre_norm + noise\n        # store tilde_z in buffer\n        self.buffer_tilde_z = tilde_z\n        z = self.bn_gamma_beta(tilde_z)\n        if self.activation is None:\n            h=z\n        else:\n            h = self.activation(z)\n        return h\n\n\nclass StackedEncoders(torch.nn.Module):\n    def __init__(self, dim_in, num_classes,dim_encoders, activation_types,\n                 noise_std,device='cpu'):\n        super(StackedEncoders, self).__init__()\n        self.buffer_tilde_z_bottom = None\n        self.encoders_ref = []\n        self.encoders = torch.nn.Sequential()\n        self.noise_level = noise_std\n        n_encoders = len(dim_encoders)+1\n        self.device=device\n        for i in range(n_encoders):\n            if i == 0:\n                dim_input = dim_in\n            else:\n                dim_input = dim_encoders[i - 1]\n            if i==n_encoders-1:\n                dim_output=num_classes\n                activation = None\n                train_batch_norm=True\n            else:\n                dim_output = dim_encoders[i]\n                activation = activation_types[i]\n                train_batch_norm=False\n\n            encoder_ref = \"encoder_\" + str(i)\n            encoder = Encoder(dim_input, dim_output, activation, train_batch_norm, noise_std,device)\n            self.encoders_ref.append(encoder_ref)\n            self.encoders.add_module(encoder_ref, encoder)\n\n    def forward_clean(self, x):\n        h = x\n        for e_ref in self.encoders_ref:\n            encoder = getattr(self.encoders, e_ref)\n            h = encoder.forward_clean(h)\n        return h\n\n    def forward_noise(self, x):\n        noise = np.random.normal(loc=0.0, scale=self.noise_level, size=x.size())\n\n        noise = Variable(torch.FloatTensor(noise).to(self.device))\n        h = x + noise\n        self.buffer_tilde_z_bottom = h.clone()\n        # pass through encoders\n        for e_ref in self.encoders_ref:\n            encoder = getattr(self.encoders, e_ref)\n            h = encoder.forward_noise(h)\n        return h\n\n    def get_encoders_tilde_z(self, reverse=True):\n        tilde_z_layers = []\n        for e_ref in self.encoders_ref:\n            encoder = getattr(self.encoders, e_ref)\n            tilde_z = encoder.buffer_tilde_z.clone()\n            tilde_z_layers.append(tilde_z)\n        if reverse:\n            tilde_z_layers.reverse()\n        return tilde_z_layers\n\n    def get_encoders_z_pre(self, reverse=True):\n        z_pre_layers = []\n        for e_ref in self.encoders_ref:\n            encoder = getattr(self.encoders, e_ref)\n            z_pre = encoder.buffer_z_pre.clone()\n            z_pre_layers.append(z_pre)\n        if reverse:\n            z_pre_layers.reverse()\n        return z_pre_layers\n\n    def get_encoders_z(self, reverse=True):\n        z_layers = []\n        for e_ref in self.encoders_ref:\n            encoder = getattr(self.encoders, e_ref)\n            z = encoder.buffer_z.clone()\n            z_layers.append(z)\n        if reverse:\n            z_layers.reverse()\n        return z_layers\n\nclass Decoder(torch.nn.Module):\n    def __init__(self, dim_in, dim_out,device='cpu'):\n        super(Decoder, self).__init__()\n\n        self.dim_in = dim_in\n        self.dim_out = dim_out\n        self.device = device\n\n\n        self.a1 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n        self.a2 = Parameter(1. * torch.ones(1, dim_in).to(self.device))\n        self.a3 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n        self.a4 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n        self.a5 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n\n        self.a6 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n        self.a7 = Parameter(1. * torch.ones(1, dim_in).to(self.device))\n        self.a8 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n        self.a9 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n        self.a10 = Parameter(0. * torch.ones(1, dim_in).to(self.device))\n\n\n        if self.dim_out is not None:\n            self.V = torch.nn.Linear(dim_in, dim_out, bias=False)\n            self.V.weight.data = torch.randn(self.V.weight.data.size()) / np.sqrt(dim_in)\n            # batch-normalization for u\n            self.bn_normalize = torch.nn.BatchNorm1d(dim_out, affine=False)\n\n        # buffer for hat_z_l to be used for cost calculation\n        self.buffer_hat_z_l = None\n\n    def g(self, tilde_z_l, u_l):\n\n        ones = Parameter(torch.ones(tilde_z_l.size()[0], 1).to(self.device))\n\n        b_a1 = ones.mm(self.a1)\n        b_a2 = ones.mm(self.a2)\n        b_a3 = ones.mm(self.a3)\n        b_a4 = ones.mm(self.a4)\n        b_a5 = ones.mm(self.a5)\n\n        b_a6 = ones.mm(self.a6)\n        b_a7 = ones.mm(self.a7)\n        b_a8 = ones.mm(self.a8)\n        b_a9 = ones.mm(self.a9)\n        b_a10 = ones.mm(self.a10)\n\n        mu_l = torch.mul(b_a1, torch.sigmoid(torch.mul(b_a2, u_l) + b_a3)) + \\\n               torch.mul(b_a4, u_l) + \\\n               b_a5\n\n        v_l = torch.mul(b_a6, torch.sigmoid(torch.mul(b_a7, u_l) + b_a8)) + \\\n              torch.mul(b_a9, u_l) + \\\n              b_a10\n\n        hat_z_l = torch.mul(tilde_z_l - mu_l, v_l) + mu_l\n\n        return hat_z_l\n\n    def forward(self, tilde_z_l, u_l):\n        # hat_z_l will be used for calculating decoder costs\n        hat_z_l = self.g(tilde_z_l, u_l)\n        # store hat_z_l in buffer for cost calculation\n        self.buffer_hat_z_l = hat_z_l\n\n        if self.dim_out is not None:\n            t = self.V.forward(hat_z_l)\n            u_l_below = self.bn_normalize(t)\n            return u_l_below\n        else:\n            return None\n\n\nclass StackedDecoders(torch.nn.Module):\n    def __init__(self, dim_in, num_classes,dim_decoders, device='cpu'):\n        super(StackedDecoders, self).__init__()\n        self.bn_u_top = torch.nn.BatchNorm1d(num_classes, affine=False)\n        self.decoders_ref = []\n        self.decoders = torch.nn.Sequential()\n        n_decoders = len(dim_decoders)+1\n        self.device=device\n        for i in range(n_decoders):\n            if i == 0:\n                dim_input = num_classes\n            else:\n                dim_input = dim_decoders[i - 1]\n            if i==n_decoders-1:\n                dim_output = dim_in\n            else:\n                dim_output = dim_decoders[i]\n            decoder_ref = \"decoder_\" + str(i)\n            decoder = Decoder(dim_input, dim_output,device=self.device)\n            self.decoders_ref.append(decoder_ref)\n            self.decoders.add_module(decoder_ref, decoder)\n\n        self.bottom_decoder = Decoder(dim_in, None,device=self.device)\n\n    def forward(self, tilde_z_layers, u_top, tilde_z_bottom):\n        # Note that tilde_z_layers should be in reversed order of encoders\n        hat_z = []\n        u = self.bn_u_top(u_top)\n        for i in range(len(self.decoders_ref)):\n            d_ref = self.decoders_ref[i]\n            decoder = getattr(self.decoders, d_ref)\n            tilde_z = tilde_z_layers[i]\n            u = decoder.forward(tilde_z, u)\n            hat_z.append(decoder.buffer_hat_z_l)\n        self.bottom_decoder.forward(tilde_z_bottom, u)\n        hat_z_bottom = self.bottom_decoder.buffer_hat_z_l.clone()\n        hat_z.append(hat_z_bottom)\n        return hat_z\n\n    def bn_hat_z_layers(self, hat_z_layers, z_pre_layers):\n        assert len(hat_z_layers) == len(z_pre_layers)\n        hat_z_layers_normalized = []\n        for i, (hat_z, z_pre) in enumerate(zip(hat_z_layers, z_pre_layers)):\n\n            ones = Variable(torch.ones(z_pre.size()[0], 1).to(self.device)) # 10*1\n            mean = torch.mean(z_pre, 0).unsqueeze(0)# 1*10\n\n            noise_var = Variable(torch.FloatTensor(np.random.normal(loc=0.0, scale=1 - 1e-10, size=z_pre.size())).to(self.device))\n            var = torch.var(z_pre.data + noise_var,dim=0).reshape(1, z_pre.size()[1])\n            hat_z_normalized = torch.div(hat_z - ones.mm(mean), ones.mm(torch.sqrt(var + 1e-10)))\n            hat_z_layers_normalized.append(hat_z_normalized)\n        return hat_z_layers_normalized\n\nclass LadderNetwork(torch.nn.Module):\n    def __init__(self, dim_encoder=[1000, 500, 250, 250, 250],\n                 encoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 noise_std=0.2,dim_in=28*28,num_classes=10,device='cpu'):\n        # >> Parameter\n        # >> - encoder_sizes: The neural network of generator.\n        # >> - encoder_activations: The activation functions of the encoder.\n        # >> - noise_std: The standard deviation of the noise.\n        # >> - dim_in: The dimension of the input samples。\n        # >> - num_classes: The number of classes.\n        # >> - device: The device to train the model.\n        super(LadderNetwork, self).__init__()\n        if isinstance(dim_in,numbers.Number):\n            input_dim = dim_in\n        else:\n            input_dim=1\n            for item in dim_in:\n                input_dim=input_dim*item\n        dim_decoder = list(reversed(dim_encoder))\n        decoder_in = num_classes\n        encoder_in = input_dim\n        self.device = device\n        self.se = StackedEncoders(encoder_in, decoder_in, dim_encoder, encoder_activations,\n                                noise_std,device)\n        self.de = StackedDecoders(encoder_in, decoder_in, dim_decoder ,device)\n        self.bn_image = torch.nn.BatchNorm1d(encoder_in, affine=False)\n\n    def forward_encoders_clean(self, data):\n        return self.se.forward_clean(data)\n\n    def forward_encoders_noise(self, data):\n        return self.se.forward_noise(data)\n\n    def forward_decoders(self, tilde_z_layers, encoder_output, tilde_z_bottom):\n        return self.de.forward(tilde_z_layers, encoder_output, tilde_z_bottom)\n\n    def get_encoders_tilde_z(self, reverse=True):\n        return self.se.get_encoders_tilde_z(reverse)\n\n    def get_encoders_z_pre(self, reverse=True):\n        return self.se.get_encoders_z_pre(reverse)\n\n    def get_encoder_tilde_z_bottom(self):\n        return self.se.buffer_tilde_z_bottom.clone()\n\n    def get_encoders_z(self, reverse=True):\n        return self.se.get_encoders_z(reverse)\n\n    def decoder_bn_hat_z_layers(self, hat_z_layers, z_pre_layers):\n        return self.de.bn_hat_z_layers(hat_z_layers, z_pre_layers)\n\n    def forward(self, data):\n        return self.forward_encoders_clean(data)"
  },
  {
    "path": "LAMDA_SSL/Network/MLPCLS.py",
    "content": "import torch\nimport torch.nn as nn\nclass MLPCLS(torch.nn.Module):\n    # define model elements\n    def __init__(self, dim_in = 28 ** 2,hidden_dim=[10],\n                 activations=[nn.ReLU()],num_classes=2):\n        # >> Parameter\n        # >> - input_dim: The dimension of input samples.\n        # >> - hidden_dim: The dimension of hidden layers.\n        # >> - activations: The activation functions used in the hidden layers.\n        super(MLPCLS, self).__init__()\n        # input to first hidden layer\n        self.num_hidden=len(hidden_dim)\n        self.activations=activations\n        self.layers=torch.nn.ModuleList()\n        self.num_classes=num_classes\n\n        for _ in range(self.num_hidden):\n            if _==0:\n                in_dim=dim_in\n            else:\n                in_dim=hidden_dim[_-1]\n            out_dim=hidden_dim[_]\n            fc=nn.Linear(in_dim, out_dim, bias=False)\n            nn.init.xavier_uniform_(fc.weight)\n            self.layers.append(fc)\n        self.final=nn.Linear(hidden_dim[self.num_hidden-1], self.num_classes, bias=False)\n\n    def forward(self, X):\n        for _ in range(self.num_hidden):\n            X = self.activations[_](self.layers[_](X))\n        if len(self.activations)==self.num_hidden+1:\n            X = self.activations[self.num_hidden](self.final(X))\n        else:\n            X=self.final(X)\n        # X=torch.flatten(X)\n        return X"
  },
  {
    "path": "LAMDA_SSL/Network/MLPReg.py",
    "content": "import torch\nimport torch.nn as nn\nclass MLPReg(torch.nn.Module):\n    # define model elements\n    def __init__(self, dim_in = 28 ** 2,hidden_dim=[10],\n                 activations=[nn.ReLU()]):\n        # >> Parameter\n        # >> - input_dim: The dimension of input samples.\n        # >> - hidden_dim: The dimension of hidden layers.\n        # >> - activations: The activation functions used in the hidden layers.\n        super(MLPReg, self).__init__()\n        # input to first hidden layer\n        self.num_hidden=len(hidden_dim)\n        self.activations=activations\n        self.layers=torch.nn.ModuleList()\n\n        for _ in range(self.num_hidden):\n            if _==0:\n                in_dim=dim_in\n            else:\n                in_dim=hidden_dim[_-1]\n            out_dim=hidden_dim[_]\n            fc=nn.Linear(in_dim, out_dim, bias=False)\n            nn.init.xavier_uniform_(fc.weight)\n            self.layers.append(fc)\n        self.final=nn.Linear(hidden_dim[self.num_hidden-1], 1, bias=False)\n\n    def forward(self, X):\n        for _ in range(self.num_hidden):\n            X = self.activations[_](self.layers[_](X))\n        if len(self.activations)==self.num_hidden+1:\n            X = self.activations[self.num_hidden](self.final(X))\n        else:\n            X=self.final(X)\n        X=torch.flatten(X)\n        return X"
  },
  {
    "path": "LAMDA_SSL/Network/ResNet50.py",
    "content": "import torch\nfrom torch import Tensor\nimport torch.nn as nn\nfrom typing import Type,  Callable, Union, List, Optional\n\n\ndef conv3x3(in_planes: int, out_planes: int, stride: int = 1, groups: int = 1, dilation: int = 1) -> nn.Conv2d:\n    \"\"\"3x3 convolution with padding\"\"\"\n    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n                     padding=dilation, groups=groups, bias=False, dilation=dilation)\n\n\ndef conv1x1(in_planes: int, out_planes: int, stride: int = 1) -> nn.Conv2d:\n    \"\"\"1x1 convolution\"\"\"\n    return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)\n\n\nclass BasicBlock(nn.Module):\n    expansion: int = 1\n\n    def __init__(\n            self,\n            inplanes: int,\n            planes: int,\n            stride: int = 1,\n            downsample: Optional[nn.Module] = None,\n            groups: int = 1,\n            base_width: int = 64,\n            dilation: int = 1,\n            norm_layer: Optional[Callable[..., nn.Module]] = None\n    ) -> None:\n\n        super(BasicBlock, self).__init__()\n        if norm_layer is None:\n            norm_layer = nn.BatchNorm2d\n        if groups != 1 or base_width != 64:\n            raise ValueError('BasicBlock only supports groups=1 and base_width=64')\n        if dilation > 1:\n            raise NotImplementedError(\"Dilation > 1 not supported in BasicBlock\")\n        # Both self.conv1 and self.downsample layers downsample the input when stride != 1\n        self.conv1 = conv3x3(inplanes, planes, stride)\n        self.bn1 = norm_layer(planes)\n        self.relu = nn.ReLU(inplace=True)\n        self.conv2 = conv3x3(planes, planes)\n        self.bn2 = norm_layer(planes)\n        self.downsample = downsample\n        self.stride = stride\n\n    def forward(self, x: Tensor) -> Tensor:\n        identity = x\n\n        out = self.conv1(x)\n        out = self.bn1(out)\n        out = self.relu(out)\n\n        out = self.conv2(out)\n        out = self.bn2(out)\n\n        if self.downsample is not None:\n            identity = self.downsample(x)\n\n        out += identity\n        out = self.relu(out)\n\n        return out\n\n\nclass Bottleneck(nn.Module):\n    # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)\n    # while original implementation places the stride at the first 1x1 convolution(self.conv1)\n    # according to \"Deep residual learning for image recognition\"https://arxiv.org/abs/1512.03385.\n    # This variant is also known as ResNet V1.5 and improves accuracy according to\n    # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.\n\n    expansion: int = 4\n\n    def __init__(\n            self,\n            inplanes: int,\n            planes: int,\n            stride: int = 1,\n            downsample: Optional[nn.Module] = None,\n            groups: int = 1,\n            base_width: int = 64,\n            dilation: int = 1,\n            norm_layer: Optional[Callable[..., nn.Module]] = None\n    ) -> None:\n        super(Bottleneck, self).__init__()\n        if norm_layer is None:\n            norm_layer = nn.BatchNorm2d\n        width = int(planes * (base_width / 64.)) * groups\n        # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n        self.conv1 = conv1x1(inplanes, width)\n        self.bn1 = norm_layer(width)\n        self.conv2 = conv3x3(width, width, stride, groups, dilation)\n        self.bn2 = norm_layer(width)\n        self.conv3 = conv1x1(width, planes * self.expansion)\n        self.bn3 = norm_layer(planes * self.expansion)\n        self.relu = nn.ReLU(inplace=True)\n        self.downsample = downsample\n        self.stride = stride\n\n    def forward(self, x: Tensor) -> Tensor:\n        identity = x\n\n        out = self.conv1(x)\n        out = self.bn1(out)\n        out = self.relu(out)\n\n        out = self.conv2(out)\n        out = self.bn2(out)\n        out = self.relu(out)\n\n        out = self.conv3(out)\n        out = self.bn3(out)\n\n        if self.downsample is not None:\n            identity = self.downsample(x)\n\n        out += identity\n        out = self.relu(out)\n\n        return out\n\n\nclass ResNet50(nn.Module):\n\n    def __init__(\n            self,\n            block: Type[Union[BasicBlock, Bottleneck]] = Bottleneck,\n            layers: List[int] = [3, 4, 6, 3],\n            num_classes: int = 1000,\n            zero_init_residual: bool = False,\n            groups: int = 1,\n            width_per_group: int = 64,\n            replace_stride_with_dilation: Optional[List[bool]] = None,\n            norm_layer: Optional[Callable[..., nn.Module]] = None\n    ) -> None:\n        # >> Parameter:\n        # >> - block: The basic network module.\n        # >> - layers: The number of repetitions of modules with hidden layers of 64, 128, 256, and 512 dimensions.\n        # >> - num_classes: The number of classes.\n        # >> - zero_init_residual: Whether to initialize residual with 0.\n        # >> - groups: The number of groups to compute in parallel.\n        # >> - width_per_group: The number of convolution kernels in each group.\n        # >> - replace_stride_with_dilation: A list or tuple of 3 bool variables. It represents whether to perform convolution expansion for 64, 128, and 256-dimensional modules.\n        # >> - norm_layer: Regularization method. The default is BatchNorm2d.\n        super(ResNet50, self).__init__()\n        if norm_layer is None:\n            norm_layer = nn.BatchNorm2d\n        self._norm_layer = norm_layer\n\n        self.inplanes = 64\n        self.dilation = 1\n        if replace_stride_with_dilation is None:\n            # each element in the tuple indicates if we should replace\n            # the 2x2 stride with a dilated convolution instead\n            replace_stride_with_dilation = [False, False, False]\n        if len(replace_stride_with_dilation) != 3:\n            raise ValueError(\"replace_stride_with_dilation should be None \"\n                             \"or a 3-element tuple, got {}\".format(replace_stride_with_dilation))\n        self.groups = groups\n        self.base_width = width_per_group\n        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,\n                               bias=False)\n        self.bn1 = norm_layer(self.inplanes)\n        self.relu = nn.ReLU(inplace=True)\n        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n        self.layer1 = self._make_layer(block, 64, layers[0])\n        self.layer2 = self._make_layer(block, 128, layers[1], stride=2,\n                                       dilate=replace_stride_with_dilation[0])\n        self.layer3 = self._make_layer(block, 256, layers[2], stride=2,\n                                       dilate=replace_stride_with_dilation[1])\n        self.layer4 = self._make_layer(block, 512, layers[3], stride=2,\n                                       dilate=replace_stride_with_dilation[2])\n        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n        self.num_classes=num_classes\n        if isinstance(self.num_classes,(list,tuple)):\n            self.fc=[]\n            for num in self.num_classes:\n                self.fc.append(nn.Linear(512 * block.expansion, num))\n        else:\n            self.fc = nn.Linear(512 * block.expansion, self.num_classes)\n\n\n        for m in self.modules():\n            if isinstance(m, nn.Conv2d):\n                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):\n                nn.init.constant_(m.weight, 1)\n                nn.init.constant_(m.bias, 0)\n\n        # Zero-initialize the last BN in each residual branch,\n        # so that the residual branch starts with zeros, and each residual block behaves like an identity.\n        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677\n        if zero_init_residual:\n            for m in self.modules():\n                if isinstance(m, Bottleneck):\n                    nn.init.constant_(m.bn3.weight, 0)  # type: ignore[arg-type]\n                elif isinstance(m, BasicBlock):\n                    nn.init.constant_(m.bn2.weight, 0)  # type: ignore[arg-type]\n\n    def _make_layer(self, block: Type[Union[BasicBlock, Bottleneck]], planes: int, blocks: int,\n                    stride: int = 1, dilate: bool = False) -> nn.Sequential:\n        norm_layer = self._norm_layer\n        downsample = None\n        previous_dilation = self.dilation\n        if dilate:\n            self.dilation *= stride\n            stride = 1\n        if stride != 1 or self.inplanes != planes * block.expansion:\n            downsample = nn.Sequential(\n                conv1x1(self.inplanes, planes * block.expansion, stride),\n                norm_layer(planes * block.expansion),\n            )\n\n        layers = []\n        layers.append(block(self.inplanes, planes, stride, downsample, self.groups,\n                            self.base_width, previous_dilation, norm_layer))\n        self.inplanes = planes * block.expansion\n        for _ in range(1, blocks):\n            layers.append(block(self.inplanes, planes, groups=self.groups,\n                                base_width=self.base_width, dilation=self.dilation,\n                                norm_layer=norm_layer))\n\n        return nn.Sequential(*layers)\n\n    def _forward_impl(self, x):\n        x = self.conv1(x)\n        x = self.bn1(x)\n        x = self.relu(x)\n        x = self.maxpool(x)\n\n        x = self.layer1(x)\n        x = self.layer2(x)\n        x = self.layer3(x)\n        x = self.layer4(x)\n\n        x = self.avgpool(x)\n        x = torch.flatten(x, 1)\n        if isinstance(self.fc,list):\n            out=[]\n            for c in self.fc:\n                out.append(c(x))\n        else:\n            out = self.fc(x)\n        return out\n\n\n    def forward(self, x):\n        return self._forward_impl(x)"
  },
  {
    "path": "LAMDA_SSL/Network/ResNet50Fc.py",
    "content": "from torchvision import models\nimport torch.nn as nn\nclass ResNet50Fc(nn.Module):\n    \"\"\"\n    ** input image should be in range of [0, 1]**\n    \"\"\"\n\n    def __init__(self, num_classes, output_feature=False):\n        super(ResNet50Fc, self).__init__()\n\n        self.model_resnet = models.resnet50(pretrained=True)\n        model_resnet = self.model_resnet\n        self.conv1 = model_resnet.conv1\n        self.bn1 = model_resnet.bn1\n        self.relu = model_resnet.relu\n        self.maxpool = model_resnet.maxpool\n        self.layer1 = model_resnet.layer1\n        self.layer2 = model_resnet.layer2\n        self.layer3 = model_resnet.layer3\n        self.layer4 = model_resnet.layer4\n        self.avgpool = model_resnet.avgpool\n        self.__in_features = model_resnet.fc.in_features\n        self.output_feature=output_feature\n        self.bottleneck = nn.Linear(self.__in_features, 256)\n        self.relu_bottle = nn.ReLU()\n        self.fc = nn.Linear(256, num_classes)\n\n    def forward(self, x):\n        x = self.conv1(x)\n        x = self.bn1(x)\n        x = self.relu(x)\n        x = self.maxpool(x)\n        x = self.layer1(x)\n        x = self.layer2(x)\n        x = self.layer3(x)\n        x = self.layer4(x)\n        x = self.avgpool(x)\n        x = x.view(x.size(0), -1)\n        x = self.bottleneck(x)\n        x= self.relu_bottle(x)\n        c = self.fc(x)\n        if self.output_feature:\n            return x, c\n        else:\n            return c\n\n    def output_num(self):\n        return self.__in_features\n"
  },
  {
    "path": "LAMDA_SSL/Network/SDNE.py",
    "content": "import torch\nimport copy\nclass SDNE(torch.nn.Module):\n    def __init__(self, dim_in, hidden_layers, device=\"cpu\"):\n        # >> Parameter:\n        # >> - input_dim: The dimension of the input samples.\n        # >> - hidden_layers: The dimension of the hidden layers.\n        # >> - device: The device to train the model.\n        super(SDNE, self).__init__()\n        self.device = device\n        dim_in_copy = copy.copy(dim_in)\n        self.dim_in = dim_in_copy\n        layers = []\n        for layer_dim in hidden_layers:\n            layers.append(torch.nn.Linear(dim_in, layer_dim))\n            layers.append(torch.nn.ReLU())\n            dim_in = layer_dim\n        self.encoder = torch.nn.Sequential(*layers)\n\n        layers = []\n        for layer_dim in reversed(hidden_layers[:-1]):\n            layers.append(torch.nn.Linear(dim_in , layer_dim))\n            layers.append(torch.nn.ReLU())\n            dim_in  = layer_dim\n\n        layers.append(torch.nn.Linear(dim_in , dim_in_copy))\n        layers.append(torch.nn.ReLU())\n        self.decoder = torch.nn.Sequential(*layers)\n\n    def forward(self,X=None):\n        Y = self.encoder(X)\n        X_hat = self.decoder(Y)\n        return Y,X_hat\n"
  },
  {
    "path": "LAMDA_SSL/Network/SSVAE.py",
    "content": "import numbers\nimport torch\nimport torch.nn as nn\nimport torch.distributions as DT\n\nclass SSVAE(nn.Module):\n    \"\"\"\n    Data model (SSL paper eq 2):\n        p(y) = Cat(y|pi)\n        p(z) = Normal(z|0,1)\n        p(x|y,z) = f(x; z,y,theta)\n    Recognition model / approximate posterior q_phi (SSL paper eq 4):\n        q(y|x) = Cat(y|pi_phi(x))\n        q(z|x,y) = Normal(z|mu_phi(x,y), diag(sigma2_phi(x)))\n    \"\"\"\n    def __init__(self, dim_in,num_classes,dim_z,dim_hidden_de=[500,500],\n                 dim_hidden_en_y=[500,500],dim_hidden_en_z=[500,500],\n                 activations_de=[nn.Softplus(),nn.Softplus()],\n                 activations_en_y=[nn.Softplus(),nn.Softplus()],\n                 activations_en_z=[nn.Softplus(),nn.Softplus()],\n                 device='cpu'):\n        # >> Parameter:\n        # >> - dim_in: The dimension of the input sample.\n        # >> - num_classes: The number of classes.\n        # >> - dim_z: The dimension of the hidden variable z.\n        # >> - dim_hidden_de: The hidden layer dimension of the decoder.\n        # >> - dim_hidden_en_y: The hidden layer dimension of the encoder for y.\n        # >> - dim_hidden_en_z: The hidden layer dimension of the encoder for z.\n        # >> - activations_de: The activation functions of the decoder.\n        # >> - activations_en_y: The activation functions of the encoder for y.\n        # >> - activations_en_z: The activation functions of the encoder for z.\n        # >> - device: The device to train the model.\n        super().__init__()\n        if isinstance(dim_in,numbers.Number):\n            input_dim = dim_in\n        else:\n            input_dim=1\n            for item in dim_in:\n                input_dim=input_dim*item\n\n        self.p_y = DT.OneHotCategorical(probs=1 / num_classes * torch.ones(1,num_classes, device=device))\n        self.p_z = DT.Normal(torch.tensor(0., device=device), torch.tensor(1., device=device))\n\n        # parametrized data likelihood p(x|y,z)\n        num_hidden=len(dim_hidden_de)\n\n        self.decoder = nn.Sequential()\n        for _ in range(num_hidden):\n            if _==0:\n                in_dim=dim_z + num_classes\n            else:\n                in_dim=dim_hidden_de[_-1]\n            out_dim=dim_hidden_de[_]\n            name = \"Linear_\" + str(_)\n            self.decoder.add_module(name=name,module=nn.Linear(in_dim,out_dim))\n            name = \"Activation_\" + str(_)\n            self.decoder.add_module(name=name,module=activations_de[_])\n        name = \"Linear_\" + str(num_hidden)\n        in_dim = dim_hidden_de[num_hidden- 1]\n        out_dim=input_dim\n        self.decoder.add_module(name=name, module=nn.Linear(in_dim,out_dim))\n        name = \"BatchNorm\"\n        self.decoder.add_module(name=name, module=nn.BatchNorm1d(out_dim, affine=False))\n        self.encoder_y = nn.Sequential()\n        num_hidden = len(dim_hidden_en_y)\n        for _ in range(num_hidden):\n            if _==0:\n                in_dim=input_dim\n            else:\n                in_dim=dim_hidden_en_y[_-1]\n            out_dim=dim_hidden_en_y[_]\n            name = \"Linear_\" + str(_)\n            self.encoder_y.add_module(name=name,module=nn.Linear(in_dim,out_dim))\n            name = \"Activation_\" + str(_)\n            self.encoder_y.add_module(name=name,module=activations_en_y[_])\n        name = \"Linear_\" + str(num_hidden)\n        in_dim = dim_hidden_en_y[num_hidden- 1]\n        out_dim=num_classes\n        self.encoder_y.add_module(name=name, module=nn.Linear(in_dim,out_dim))\n\n        # parametrized q(z|x,y) = Normal(z|mu_phi(x,y), diag(sigma2_phi(x)))\n        self.encoder_z = nn.Sequential()\n        num_hidden = len(dim_hidden_en_z)\n        for _ in range(num_hidden):\n            if _==0:\n                in_dim=input_dim + num_classes\n            else:\n                in_dim=dim_hidden_en_z[_-1]\n            out_dim=dim_hidden_en_z[_]\n            name = \"Linear_\" + str(_)\n            self.encoder_z.add_module(name=name,module=nn.Linear(in_dim,out_dim))\n            name = \"Activation_\" + str(_)\n            self.encoder_z.add_module(name=name,module=activations_en_z[_])\n        name = \"Linear_\" + str(num_hidden)\n        in_dim = dim_hidden_en_z[num_hidden- 1]\n        out_dim=2 * dim_z\n        self.encoder_z.add_module(name=name, module=nn.Linear(in_dim,out_dim))\n\n        for p in self.parameters():\n            p.data.normal_(0, 0.001)\n            if p.ndimension() == 1: p.data.fill_(0.)\n\n    # q(z|x,y) = Normal(z|mu_phi(x,y), diag(sigma2_phi(x))) -- SSL paper eq 4\n    def encode_z(self, x, y):\n        xy = torch.cat([x, y], dim=1)\n        mu, logsigma = self.encoder_z(xy).chunk(2, dim=-1)\n        return DT.Normal(mu, logsigma.exp())\n\n    # q(y|x) = Categorical(y|pi_phi(x)) -- SSL paper eq 4\n    def encode_y(self, x):\n        return DT.OneHotCategorical(logits=self.encoder_y(x))\n\n    # p(x|y,z) = Bernoulli\n    def decode(self, y, z):\n        yz = torch.cat([y, z], dim=1)\n        reconstruction = DT.Bernoulli(logits=self.decoder(yz))\n        return reconstruction\n\n    # classification model q(y|x) using the trained q distribution\n    def forward(self, x):\n        y_probs = self.encode_y(x).probs\n        return y_probs"
  },
  {
    "path": "LAMDA_SSL/Network/TextRCNN.py",
    "content": "import torch.nn as nn\nimport torch\n\n\nclass TextRCNN(nn.Module):\n\n    def __init__(self, n_vocab,embedding_dim=300,len_seq=300, padding_idx=None, hidden_size=256, num_layers=1,\n                 dropout=0.0, pretrained_embeddings=None,num_classes=2):\n        # >> Parameter:\n        # >> - n_vocab: The size of the dictionary.\n        # >> - embedding_dim: The dimension of the word embedding.\n        # >> - len_seq: The length of the sentence.\n        # >> - padding_idx: If specified, the entries at 'padding_idx' do not contribute to the gradient; therefore, the embedding vector at 'padding_idx' is not updated during training, i.e. it remains as a fixed \"pad\". For a newly constructed Embedding, the embedding vector at 'padding_idx' will default to all zeros, but can be updated to another value to be used as the padding vector.\n        # >> - hidden_size: The dimension of the hidden layer.\n        # >> - num_layers: The number of network layers.\n        # >> - dropout: The dropout rate.\n        # >> - pretrained_embeddings: The pretrained word embeddings.\n        super(TextRCNN, self).__init__()\n\n        if pretrained_embeddings is not None:\n            self.embedding = nn.Embedding.from_pretrained(pretrained_embeddings, freeze=True)\n        else:\n            self.embedding = nn.Embedding(n_vocab, embedding_dim, padding_idx=padding_idx)\n        self.lstm = nn.LSTM(embedding_dim, hidden_size, num_layers,\n                            bidirectional=True, batch_first=True, dropout=dropout)\n        self.fc = nn.Linear(hidden_size * 2 +embedding_dim, hidden_size * 2)\n        self.maxpool = nn.MaxPool1d(len_seq)\n        self.classfier = nn.Linear(hidden_size * 2, num_classes)\n        self.dropout = nn.Dropout(dropout)\n\n\n    def forward(self, x):\n        # print(x.dtype)\n        x=x.long()\n        embed = self.embedding(x)  # [batch_size, seq_len, embeding]=[64, 32, 64]\n        # print(embed.shape)# [300,300]\n        out, _ = self.lstm(embed)\n        # print(out.shape)#[300,512]\n        out = torch.cat((embed, out), 2)\n        # print(out.shape) # [300,812]\n        fc_output = torch.tanh(self.fc(out))   # [batch_size, max_seq_len, hidden_size*2]\n\n        maxpool_input = fc_output.permute(0, 2, 1)  # [batch_size, hidden_size*2, max_seq_len]\n        maxpool_output = self.maxpool(maxpool_input).squeeze()   # [batch_size, hidden_size*2]\n\n        cls_input = self.dropout(maxpool_output)\n        out = self.classfier(cls_input)\n\n        return out"
  },
  {
    "path": "LAMDA_SSL/Network/WideResNet.py",
    "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.nn import ModuleList\n# momentum = 0.001\n\n\ndef mish(x):\n    \"\"\"Mish: A Self Regularized Non-Monotonic Neural Activation Function (https://arxiv.org/abs/1908.08681)\"\"\"\n    return x * torch.tanh(F.softplus(x))\n\n\nclass PSBatchNorm2d(nn.BatchNorm2d):\n    \"\"\"How Does BN Increase Collapsed Neural Network Filters? (https://arxiv.org/abs/2001.11216)\"\"\"\n\n    def __init__(self, num_features, alpha=0.1, eps=1e-05, momentum=0.001, affine=True, track_running_stats=True):\n        super().__init__(num_features, eps, momentum, affine, track_running_stats)\n        self.alpha = alpha\n\n    def forward(self, x):\n        return super().forward(x) + self.alpha\n\n\nclass BasicBlock(nn.Module):\n    def __init__(self, in_planes, out_planes, stride, drop_rate=0.0, activate_before_residual=False):\n        super(BasicBlock, self).__init__()\n        self.bn1 = nn.BatchNorm2d(in_planes, momentum=0.001, eps=0.001)\n        self.relu1 = nn.LeakyReLU(negative_slope=0.1, inplace=False)\n        self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n                               padding=1, bias=True)\n        self.bn2 = nn.BatchNorm2d(out_planes, momentum=0.001, eps=0.001)\n        self.relu2 = nn.LeakyReLU(negative_slope=0.1, inplace=False)\n        self.conv2 = nn.Conv2d(out_planes, out_planes, kernel_size=3, stride=1,\n                               padding=1, bias=True)\n        self.drop_rate = drop_rate\n        self.equalInOut = (in_planes == out_planes)\n        self.convShortcut = (not self.equalInOut) and nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride,\n                                                                padding=0, bias=True) or None\n        self.activate_before_residual = activate_before_residual\n\n    def forward(self, x):\n        if not self.equalInOut and self.activate_before_residual == True:\n            x = self.relu1(self.bn1(x))\n        else:\n            out = self.relu1(self.bn1(x))\n        out = self.relu2(self.bn2(self.conv1(out if self.equalInOut else x)))\n        if self.drop_rate > 0:\n            out = F.dropout(out, p=self.drop_rate, training=self.training)\n        out = self.conv2(out)\n        return torch.add(x if self.equalInOut else self.convShortcut(x), out)\n\n\nclass NetworkBlock(nn.Module):\n    def __init__(self, nb_layers, in_planes, out_planes, block, stride, drop_rate=0.0, activate_before_residual=False):\n        super(NetworkBlock, self).__init__()\n        self.layer = self._make_layer(\n            block, in_planes, out_planes, nb_layers, stride, drop_rate, activate_before_residual)\n\n    def _make_layer(self, block, in_planes, out_planes, nb_layers, stride, drop_rate, activate_before_residual):\n        layers = []\n        for i in range(int(nb_layers)):\n            layers.append(block(i == 0 and in_planes or out_planes, out_planes,\n                                i == 0 and stride or 1, drop_rate, activate_before_residual))\n        return nn.Sequential(*layers)\n\n    def forward(self, x):\n        return self.layer(x)\n\n\nclass WideResNet(nn.Module):\n    def __init__(self,  num_classes=10, depth=28, widen_factor=2, drop_rate=0.0, channel_in=3,output_features=False):\n        # >> Parameter:\n        # >> - num_classes: The number of classes.\n        # >> - depth: The depth of network.\n        # >> - widen_factor: The width of the network.It is used to determine hidden layer dimensions.\n        # >> - dropout: The dropout rate.\n        super(WideResNet, self).__init__()\n        self.channels=channel_in\n        channels = [16, 16 * widen_factor, 32 * widen_factor, 64 * widen_factor]\n        assert ((depth - 4) % 6 == 0)\n        n = (depth - 4) / 6\n        block = BasicBlock\n        # 1st conv before any network block\n        self.conv1 = nn.Conv2d(channel_in, channels[0], kernel_size=3, stride=1,\n                               padding=1, bias=True)\n        # 1st block\n        self.block1 = NetworkBlock(\n            n, channels[0], channels[1], block, 1, drop_rate, activate_before_residual=True)\n        # 2nd block\n        self.block2 = NetworkBlock(\n            n, channels[1], channels[2], block, 2, drop_rate)\n        # 3rd block\n        self.block3 = NetworkBlock(\n            n, channels[2], channels[3], block, 2, drop_rate)\n        # global average pooling and classifier\n        self.bn1 = nn.BatchNorm2d(channels[3], momentum=0.001, eps=0.001)\n        self.relu = nn.LeakyReLU(negative_slope=0.1, inplace=False)\n        self.num_classes=num_classes\n        if isinstance(self.num_classes,(list,tuple)):\n            self.fc=ModuleList([])\n            for num in self.num_classes:\n                self.fc.append(nn.Linear(channels[3], num))\n        else:\n            self.fc = nn.Linear(channels[3], self.num_classes)\n        self.channels = channels[3]\n\n        for m in self.modules():\n            if isinstance(m, nn.Conv2d):\n                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='leaky_relu')\n            elif isinstance(m, nn.BatchNorm2d):\n                m.weight.data.fill_(1)\n                m.bias.data.zero_()\n            elif isinstance(m, nn.Linear):\n                nn.init.xavier_normal_(m.weight.data)\n                m.bias.data.zero_()\n        self.output_features=output_features\n\n    def forward(self, x):\n        if len(x.shape)==3  and self.channels==1:\n            x=torch.unsqueeze(x,dim=1)\n        out = self.conv1(x)\n        out = self.block1(out)\n        out = self.block2(out)\n        out = self.block3(out)\n        out = self.relu(self.bn1(out))\n        out = F.adaptive_avg_pool2d(out, 1)\n        out = out.view(-1, self.channels)\n        self.features=out\n        if isinstance(self.fc, ModuleList):\n            output = []\n            for c in self.fc:\n                output.append(c(out))\n        else:\n            output = self.fc(out)\n        if self.output_features:\n            return self.features,output\n        else:\n            return output"
  },
  {
    "path": "LAMDA_SSL/Network/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Opitimizer/Adam.py",
    "content": "from LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nfrom torch.optim import adam\nclass Adam(BaseOptimizer):\n    def __init__(self,lr=1e-3, betas=(0.9, 0.999), eps=1e-8,\n                 weight_decay=0, amsgrad=False):\n        # >> Parameter:\n        # >> - lr: learning rate.\n        # >> - betas: Coefficients used for computing running averages of gradient and its square.\n        # >> - eps: Term added to the denominator to improve numerical stability\n        # >> - weight_decay: Weight decay (L2 penalty)\n        # >> - amsgrad: whether to use the AMSGrad variant of this algorithm from the paper 'On the Convergence of Adam and Beyond'.\n        self.lr=lr\n        self.betas=betas\n        self.eps=eps\n        self.weight_decay=weight_decay\n        self.amsgrad=amsgrad\n        defaults = dict(lr=lr, betas=betas, eps=eps,\n                        weight_decay=weight_decay, amsgrad=amsgrad)\n        super().__init__(defaults=defaults)\n\n    def init_optimizer(self,params):\n        return adam.Adam(params=params,lr=self.lr,betas=self.betas,eps=self.eps,\n                    weight_decay=self.weight_decay,amsgrad=self.amsgrad)\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Opitimizer/SGD.py",
    "content": "from LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nfrom torch.optim import  sgd\n\nclass SGD(BaseOptimizer):\n    def __init__(self, lr=0.01, momentum=0, dampening=0, weight_decay=0, nesterov=False):\n        # >> Parameter:\n        # >> - lr: Learning rate.\n        # >> - momentum: Momentum factor.\n        # >> - dampening: Dampening for momentum.\n        # >> - weight_decay: Weight decay (L2 penalty).\n        # >> - nesterov: Enables Nesterov momentum.\n        self.lr=lr\n        self.momentum=momentum\n        self.dampening=dampening\n        self.weight_decay=weight_decay\n        self.nesterov=nesterov\n        defaults = dict(lr=lr, momentum=momentum, dampening=dampening,\n                        weight_decay=weight_decay, nesterov=nesterov)\n\n        super().__init__(defaults)\n\n    def init_optimizer(self,params):\n        opti=sgd.SGD(params=params, lr=self.lr, momentum=self.momentum, dampening=self.dampening,\n                   weight_decay=self.weight_decay, nesterov=self.nesterov)\n        return opti\n\n\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Opitimizer/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Sampler/BatchSampler.py",
    "content": "from LAMDA_SSL.Base.BaseSampler import BaseSampler\nimport torch.utils.data.sampler as torchsampler\nclass BatchSampler(BaseSampler):\n    def __init__(self, batch_size: int, drop_last: bool):\n        super().__init__()\n        # >> Parameter:\n        # >> - batch_size: The number of samples in each batch.\n        # >> - drop_last: Whether to discard samples less than one batch.\n        self.batch_size=batch_size\n        self.drop_last=drop_last\n\n    def init_sampler(self,sampler):\n        # >> init_sampler(sampler): Initialize batch sampler with sampler.\n        # >> sampler: The sampler used to initial batch sampler.\n        return torchsampler.BatchSampler(sampler=sampler,batch_size=self.batch_size,drop_last=self.drop_last)"
  },
  {
    "path": "LAMDA_SSL/Sampler/DistributedSampler.py",
    "content": "import  torch.utils.data.distributed as dt\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nclass DistributedSampler(BaseSampler):\n    def __init__(self,num_replicas=None, rank=None, shuffle=True, seed=0, drop_last=False):\n        # > - Parameter:\n        # >> - num_replicas: The Number of processes participating in distributed training.\n        # >> - rank : Rank of the current process within `num_replicas`.\n        # >> - shuffle: Whether to shuffle the data.\n        # >> - seed: The random seed.\n        # >> - drop_last: Whether to discard samples less than one batch.\n        self.num_replicas=num_replicas\n        self.rank=rank\n        self.shuffle=shuffle\n        self.seed=seed\n        self.drop_last=drop_last\n        super().__init__()\n\n    def init_sampler(self,data_source):\n        # >> init_sampler(data_source):  Initialize the sampler with data.\n        # >> - data_source: The data to be sampled.\n        return dt.DistributedSampler(dataset=data_source,num_replicas=self.num_replicas,rank=self.rank,\n                                     shuffle=self.shuffle,seed=self.seed,drop_last=self.drop_last)"
  },
  {
    "path": "LAMDA_SSL/Sampler/RandomSampler.py",
    "content": "from LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom torch.utils.data import sampler\nclass RandomSampler(BaseSampler):\n    def __init__(self,replacement: bool = False,\n                 num_samples = None, generator=None):\n        # >> Parameter:\n        # >> - replacement: samples are drawn on-demand with replacement if True.\n        # >> - num_samples: The number of samples\n        # >> - generator: Generator used in sampling.\n\n        super().__init__()\n        self.replacement=replacement\n        self.num_samples=num_samples\n        self.generator=generator\n    def init_sampler(self,data_source):\n        # >> init_sampler(data_source):  Initialize the sampler with data.\n        # >> - data_source: The data to be sampled.\n        return sampler.RandomSampler(data_source=data_source,replacement=self.replacement,\n                                     num_samples=self.num_samples,generator=self.generator)"
  },
  {
    "path": "LAMDA_SSL/Sampler/SequentialSampler.py",
    "content": "from LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom torch.utils.data import sampler\nclass SequentialSampler(BaseSampler):\n    def __init__(self):\n        super().__init__()\n    def init_sampler(self,data_source):\n        # >> init_sampler(data_source):  Initialize the sampler with data.\n        # >> - data_source: The data to be sampled.\n        return sampler.SequentialSampler(data_source=data_source)"
  },
  {
    "path": "LAMDA_SSL/Sampler/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Scheduler/CosineAnnealingLR.py",
    "content": "from torch.optim import lr_scheduler\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\nclass CosineAnnealingLR(BaseScheduler):\n    def __init__(self,  T_max, eta_min=0, last_epoch=-1, verbose=False):\n        # >> Parameter:\n        # >> - T_max: Maximum number of iterations.\n        # >> - eta_min: Minimum learning rate.\n        # >> - last_epoch: The index of last epoch.\n        # >> - verbose: If 'True', prints a message to stdout for each update.\n        super().__init__(last_epoch=last_epoch,verbose=verbose)\n        self.T_max=T_max\n        self.eta_min=eta_min\n    def init_scheduler(self,optimizer):\n        return lr_scheduler.CosineAnnealingLR(optimizer=optimizer,T_max=self.T_max,eta_min=self.eta_min,\n                                              last_epoch=self.last_epoch,verbose=self.verbose)\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Scheduler/CosineWarmup.py",
    "content": "from LAMDA_SSL.Base.LambdaLR import LambdaLR\nimport math\nclass CosineWarmup(LambdaLR):\n    def __init__(self,\n                 num_training_steps,\n                 num_warmup_steps=0,\n                 num_cycles=7./16,\n                 last_epoch=-1,\n                 verbose=False):\n        # >> Parameter:\n        # >> - num_training_steps: The total number of iterations for training.\n        # >> - num_warmup_steps: The number of iterations to warm up.\n        # >> - num_cycles: The upperbound of the multiplicative factor is num_cycles PI.\n        # >> - last_epoch: The index of the last epoch.\n        # >> - verbose: Whether to output redundant information.\n        self.num_warmup_steps=num_warmup_steps\n        self.num_cycles=num_cycles\n        self.num_training_steps=num_training_steps\n        self.verbose=verbose\n        super().__init__(lr_lambda=self._lr_lambda,last_epoch=last_epoch,verbose=self.verbose)\n\n    def _lr_lambda(self,current_step):\n        if current_step < self.num_warmup_steps:\n            return float(current_step) / float(max(1, self.num_warmup_steps))\n        no_progress = float(current_step - self.num_warmup_steps) / \\\n            float(max(1, self.num_training_steps - self.num_warmup_steps))\n        return max(0., math.cos(math.pi * self.num_cycles * no_progress))\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Scheduler/InverseDecaySheduler.py",
    "content": "from LAMDA_SSL.Base.LambdaLR import LambdaLR\n\nclass InverseDecaySheduler(LambdaLR):\n    def __init__(self, initial_lr, gamma=10, power=0.75, max_iter=1000):\n        self.initial_lr=initial_lr\n        self.gamma=gamma\n        self.power=power\n        self.max_iter=max_iter\n\n    def _lr_lambda(self, current_step):\n        return self.initial_lr * ((1 + self.gamma * min(1.0, current_step / float(self.max_iter))) ** (- self.power))"
  },
  {
    "path": "LAMDA_SSL/Scheduler/LinearWarmup.py",
    "content": "from LAMDA_SSL.Base.LambdaLR import LambdaLR\n\nclass LinearWarmup(LambdaLR):\n    def __init__(self,\n                 num_training_steps,\n                 num_warmup_steps=0,\n                 start_factor=0,\n                 end_factor=1,\n                 last_epoch=-1,\n                 verbose=False):\n        # >> Parameter:\n        # >> - num_training_steps: The total number of iterations for training.\n        # >> - num_warmup_steps: The number of iterations to warm up.\n        # >> - start_factor: The initialchange factor of the learning rate.\n        # >> - end_factor: The final change factor of the learning rate.\n        # >> - last_epoch: The index of the last epoch.\n        # >> - verbose: Whether to output redundant information.\n        self.start_factor=start_factor\n        self.end_factor=end_factor\n        self.num_warmup_steps=num_warmup_steps\n        self.num_training_steps=num_training_steps\n        self.verbose=verbose\n        super().__init__(lr_lambda=self._lr_lambda,last_epoch=last_epoch,verbose=self.verbose)\n\n    def _lr_lambda(self,current_step):\n        if current_step > self.num_warmup_steps:\n            return  self.start_factor+float(self.num_training_steps - current_step) \\\n                    / (self.num_training_steps - self.num_warmup_steps)*(self.end_factor-self.start_factor)\n        return 1\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Scheduler/StepLR.py",
    "content": "from torch.optim import lr_scheduler\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\nclass StepLR(BaseScheduler):\n    def __init__(self,  step_size, gamma=0.1, last_epoch=-1, verbose=False):\n        # >> Parameter:\n        # >> - step_size: Period of learning rate decay.\n        # >> - gamma: Multiplicative factor of learning rate decay.\n        # >> - last_epoch: The index of last epoch.\n        # >> - verbose: If 'True', prints a message to stdout for each update.\n        super().__init__(last_epoch=last_epoch,verbose=verbose)\n        self.step_size=step_size\n        self.gamma=gamma\n        self.last_epoch=last_epoch\n        self.verbose=verbose\n\n    def init_scheduler(self,optimizer):\n        return lr_scheduler.StepLR(optimizer=optimizer,step_size=self.step_size,gamma=self.gamma,last_epoch=self.last_epoch,verbose=self.verbose)\n"
  },
  {
    "path": "LAMDA_SSL/Scheduler/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Search/BayesSearchCV.py",
    "content": "from sklearn.model_selection._search import BaseSearchCV,ParameterGrid\nfrom collections.abc import Mapping\nfrom sklearn.utils import check_random_state\nimport numpy as np\nimport time\nfrom sklearn.model_selection._validation import _fit_and_score\nfrom sklearn.model_selection._validation import _insert_error_scores\nfrom sklearn.model_selection._validation import _warn_about_fit_failures\nfrom collections import defaultdict\nfrom sklearn.model_selection._split import check_cv\nfrom sklearn.metrics._scorer import _check_multimetric_scoring\nfrom sklearn.metrics import check_scoring\nfrom sklearn.utils.validation import indexable, _check_fit_params\nfrom joblib import Parallel\nfrom itertools import product\nfrom sklearn.base import  is_classifier, clone\nfrom sklearn.utils.fixes import delayed\nfrom sklearn.model_selection._search import ParameterSampler\nfrom sklearn.gaussian_process import GaussianProcessRegressor\nfrom scipy.stats import norm\n\n\ndef PI(x,gp,y_max=1,xi=0.01,kappa=None):\n    mean,std=gp.predict(x,return_std=True)\n    z=(mean-y_max-xi)/std\n    return norm.cdf(z)\n\ndef EI(x,gp,y_max=1,xi=0.01,kappa=None):\n    mean,std=gp.predict(x,return_std=True)\n    a=(mean-y_max-xi)\n    z=a/std\n    return a*norm.cdf(z)+std*norm.pdf(z)\n\ndef UCB(x,gp,y_max=None,xi=None,kappa=0.1):\n    mean,std=gp.predict(x,return_std=True)\n    return mean+kappa*std\n\nclass BayesSearchCV(BaseSearchCV):\n    def __init__(\n        self,\n        estimator,\n        param_distributions,\n        n_iter=10,\n        random_state=None,\n        warm_up=2,\n        lam=3,\n        y_max=1, xi=0.01, kappa=None,\n        acquisition_func='PI',\n        scoring=None,\n        n_jobs=None,\n        refit=True,\n        cv=None,\n        verbose=0,\n        pre_dispatch=\"2*n_jobs\",\n        error_score=np.nan,\n        return_train_score=True,\n    ):\n        # >> - estimator: This is assumed to implement the scikit-learn estimator interface.\n        # >> - param_distributions: Dictionary with parameters names ('str') as keys and distributions or lists of parameters to try. Distributions must provide a 'rvs' method for sampling (such as those from scipy.stats.distributions). If a list is given, it is sampled uniformly. If a list of dicts is given, first a dict is sampled uniformly, and then a parameter is sampled using that dict as above.\n        # >> - n_iter: Number of iterations.\n        # >> - random_state: The state of random seed.\n        # >> - warm_up: The number of times to randomly sample parameters in the initial state.\n        # >> - lam: The number of parameter groups that need to be sampled for evaluation per iteration.\n        # >> - y_max: Valid when acquisition_func is 'PI' and 'EI', it represents the maximum value of the score.\n        # >> - xi: Valid when acquisition_func is 'PI' and 'EI', the parameter used to trade off exploration and explotitation.\n        # >> - kappa: Valid when acquisition_func is 'UCB', it is used to trade off mean and variance.\n        # >> - acquisition_func: The function to estimate the score of the parameter group, optional 'PI', 'EI' and 'UCB' or a function that can be called.\n        # >> - scoring: Strategy to evaluate the performance of the cross-validated model on the test set.\n        # >> - n_jobs: Number of jobs to run in parallel.\n        # >> - refit: Refit an estimator using the best found parameters on the whole dataset.\n        # >> - cv: Determines the cross-validation splitting strategy. Int, cross-validation generator or an iterable.\n        # >> - verbose: Controls the verbosity: the higher, the more messages.\n        # >> - pre_dispatch: Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process.\n        # >> - error_score: Value to assign to the score if an error occurs in estimator fitting.\n        # >> - return_train_score: If 'False', the 'cv_results_' attribute will not include training scores.\n        super().__init__(\n            estimator=estimator,\n            scoring=scoring,\n            n_jobs=n_jobs,\n            refit=refit,\n            cv=cv,\n            verbose=verbose,\n            pre_dispatch=pre_dispatch,\n            error_score=error_score,\n            return_train_score=return_train_score,\n        )\n        self.lam=lam\n        self.warm_up=warm_up\n        self.param_distributions = param_distributions\n        self.n_iter = n_iter\n        self.random_state = random_state\n        self.acquisition_func=acquisition_func\n        self.y_max=y_max\n        self.xi=xi\n        self.kappa=kappa\n\n    def _run_search(self, evaluate_candidates):\n        \"\"\"Search n_iter candidates from param_distributions\"\"\"\n        evaluate_candidates(\n            ParameterSampler(\n                self.param_distributions, self.warm_up, random_state=self.random_state\n            )\n        )\n\n    def fit(self, X, y=None, *, groups=None, **fit_params):\n        self.GP = GaussianProcessRegressor()\n        estimator = self.estimator\n        refit_metric = \"score\"\n\n        if callable(self.scoring):\n            scorers = self.scoring\n        elif self.scoring is None or isinstance(self.scoring, str):\n            scorers = check_scoring(self.estimator, self.scoring)\n        else:\n            scorers = _check_multimetric_scoring(self.estimator, self.scoring)\n            self._check_refit_for_multimetric(scorers)\n            refit_metric = self.refit\n\n        X, y, groups = indexable(X, y, groups)\n        fit_params = _check_fit_params(X, fit_params)\n\n        cv_orig = check_cv(self.cv, y, classifier=is_classifier(estimator))\n        n_splits = cv_orig.get_n_splits(X, y, groups)\n\n        base_estimator = clone(self.estimator)\n\n        parallel = Parallel(n_jobs=self.n_jobs, pre_dispatch=self.pre_dispatch)\n\n        fit_and_score_kwargs = dict(\n            scorer=scorers,\n            fit_params=fit_params,\n            return_train_score=self.return_train_score,\n            return_n_test_samples=True,\n            return_times=True,\n            return_parameters=False,\n            error_score=self.error_score,\n            verbose=self.verbose,\n        )\n        if self.acquisition_func is 'PI':\n            self.acquisition_func=PI\n        elif self.acquisition_func is 'EI':\n            self.acquisition_func=EI\n        elif self.acquisition_func is 'UCB':\n            self.acquisition_func=UCB\n        elif callable(self.acquisition_func):\n            self.acquisition_func=self.acquisition_func\n        else:\n            self.acquisition_func = PI\n        results = {}\n        all_candidate_params = []\n        all_out = []\n        all_more_results = defaultdict(list)\n\n        def evaluate_candidates(candidate_params, cv=None, more_results=None):\n            cv = cv or cv_orig\n            candidate_params = list(candidate_params)\n            n_candidates = len(candidate_params)\n\n            if self.verbose > 0:\n                print(\n                    \"Fitting {0} folds for each of {1} candidates,\"\n                    \" totalling {2} fits\".format(\n                        n_splits, n_candidates, n_candidates * n_splits\n                    )\n                )\n\n            out = parallel(\n                delayed(_fit_and_score)(\n                    clone(base_estimator),\n                    X,\n                    y,\n                    train=train,\n                    test=test,\n                    parameters=parameters,\n                    split_progress=(split_idx, n_splits),\n                    candidate_progress=(cand_idx, n_candidates),\n                    **fit_and_score_kwargs,\n                )\n                for (cand_idx, parameters), (split_idx, (train, test)) in product(\n                    enumerate(candidate_params), enumerate(cv.split(X, y, groups))\n                )\n            )\n\n            if len(out) < 1:\n                raise ValueError(\n                    \"No fits were performed. \"\n                    \"Was the CV iterator empty? \"\n                    \"Were there no candidates?\"\n                )\n            elif len(out) != n_candidates * n_splits:\n                raise ValueError(\n                    \"cv.split and cv.get_n_splits returned \"\n                    \"inconsistent results. Expected {} \"\n                    \"splits, got {}\".format(n_splits, len(out) // n_candidates)\n                )\n\n            _warn_about_fit_failures(out, self.error_score)\n\n            # For callable self.scoring, the return type is only know after\n            # calling. If the return type is a dictionary, the error scores\n            # can now be inserted with the correct key. The type checking\n            # of out will be done in `_insert_error_scores`.\n            if callable(self.scoring):\n                _insert_error_scores(out, self.error_score)\n\n            all_candidate_params.extend(candidate_params)\n            all_out.extend(out)\n\n            if more_results is not None:\n                for key, value in more_results.items():\n                    all_more_results[key].extend(value)\n\n            nonlocal results\n            results = self._format_results(\n                all_candidate_params, n_splits, all_out, all_more_results\n            )\n            return results\n\n        with parallel:\n            self._run_search(evaluate_candidates)\n\n        first_test_score = all_out[0][\"test_scores\"]\n        self.multimetric_ = isinstance(first_test_score, dict)\n\n        if callable(self.scoring) and self.multimetric_:\n            self._check_refit_for_multimetric(first_test_score)\n            refit_metric = self.refit\n        params = results['params']\n        score = results[f\"mean_test_{refit_metric}\"]\n        _X=[]\n        for _ in range(self.warm_up):\n            _X.append(list(params[_].values()))\n        _X=np.array(_X)\n        _y=score\n        for _ in range(self.n_iter):\n            self.GP.fit(_X, _y)\n            condidate_params=list(ParameterSampler(\n                self.param_distributions, self.lam, random_state=self.random_state\n            ))\n            _test_X=[]\n            for _ in range(self.lam):\n                _test_X.append(list(condidate_params[_].values()))\n            _test_X=np.array(_test_X)\n            _pred_y=self.acquisition_func(_test_X,gp=self.GP,y_max=self.y_max,xi=self.xi,kappa=self.kappa)\n            idx=_pred_y.argmax()\n            _params=dict()\n            key_idx=0\n            for key in list(self.param_distributions.keys()):\n                _params[key]=_test_X[idx][key_idx]\n            evaluate_candidates([_params])\n            _X = np.concatenate((_X, np.expand_dims(_test_X[idx],axis=0)), axis=0)\n            _y= np.concatenate((_y,np.array([_pred_y[idx]])),axis=0)\n\n        first_test_score = all_out[0][\"test_scores\"]\n        self.multimetric_ = isinstance(first_test_score, dict)\n\n        if callable(self.scoring) and self.multimetric_:\n            self._check_refit_for_multimetric(first_test_score)\n            refit_metric = self.refit\n\n        self.best_index_ = self._select_best_index(\n            self.refit, refit_metric, results\n        )\n        # With a non-custom callable, we can select the best score\n        # based on the best index\n        self.best_score_ = results[f\"mean_test_{refit_metric}\"][\n            self.best_index_\n        ]\n        self.best_params_ = results[\"params\"][self.best_index_]\n\n        if self.refit:\n            # we clone again after setting params in case some\n            # of the params are estimators as well.\n            self.best_estimator_ = clone(\n                clone(base_estimator).set_params(**self.best_params_)\n            )\n            refit_start_time = time.time()\n            if y is not None:\n                self.best_estimator_.fit(X, y, **fit_params)\n            else:\n                self.best_estimator_.fit(X, **fit_params)\n            refit_end_time = time.time()\n            self.refit_time_ = refit_end_time - refit_start_time\n\n            if hasattr(self.best_estimator_, \"feature_names_in_\"):\n                self.feature_names_in_ = self.best_estimator_.feature_names_in_\n\n        # Store the only scorer not as a dict for single metric evaluation\n        self.scorer_ = scorers\n\n        self.cv_results_ = results\n        self.n_splits_ = n_splits\n\n        return self\n"
  },
  {
    "path": "LAMDA_SSL/Search/EvolutionaryStrategySearchCV.py",
    "content": "import copy\nimport random\n\nfrom sklearn.model_selection._search import BaseSearchCV,ParameterGrid\nfrom collections.abc import Mapping, Iterable\nfrom sklearn.utils import check_random_state\nimport numpy as np\nimport time\nfrom sklearn.model_selection._validation import _fit_and_score\nfrom sklearn.model_selection._validation import _insert_error_scores\nfrom sklearn.model_selection._validation import _warn_about_fit_failures\nfrom collections import defaultdict\nfrom sklearn.model_selection._split import check_cv\nfrom sklearn.metrics._scorer import _check_multimetric_scoring\nfrom sklearn.metrics import check_scoring\nfrom sklearn.utils.validation import indexable, _check_fit_params\nfrom joblib import Parallel\nfrom itertools import product\nfrom sklearn.base import  is_classifier, clone\nfrom sklearn.utils.fixes import delayed\n\nclass Evolve:\n    # 1+\\lambda\n    def __init__(self, param_distributions, *, random_state=None,lam=5,ancestors=None):\n        if not isinstance(param_distributions, (Mapping, Iterable)):\n            raise TypeError(\n                \"Parameter distribution is not a dict or a list ({!r})\".format(\n                    param_distributions\n                )\n            )\n\n        if isinstance(param_distributions, Mapping):\n            # wrap dictionary in a singleton list to support either dict\n            # or list of dicts\n            param_distributions = [param_distributions]\n\n        for dist in param_distributions:\n            if not isinstance(dist, dict):\n                raise TypeError(\n                    \"Parameter distribution is not a dict ({!r})\".format(dist)\n                )\n            for key in dist:\n                if not isinstance(dist[key], Iterable) and not hasattr(\n                    dist[key], \"rvs\"\n                ):\n                    raise TypeError(\n                        \"Parameter value is not iterable \"\n                        \"or distribution (key={!r}, value={!r})\".format(key, dist[key])\n                    )\n        self.random_state = random_state\n        self.param_distributions = param_distributions\n        self.lam=lam\n        self.ancestors=ancestors\n\n    def _is_all_lists(self):\n        return all(\n            all(not hasattr(v, \"rvs\") for v in dist.values())\n            for dist in self.param_distributions\n        )\n\n    def __iter__(self):\n        rng = check_random_state(self.random_state)\n\n        # if all distributions are given as lists, we want to sample without\n        # replacement\n        for _ in range(self.lam):\n            dist = rng.choice(self.param_distributions)\n            # Always sort the keys of a dictionary, for reproducibility\n            items = sorted(dist.items())\n            params = copy.copy(self.ancestors)\n            Mutation_key,Mutation_val=random.choice(items)\n            if hasattr(Mutation_val, \"rvs\"):\n                params[Mutation_key] = Mutation_val.rvs(random_state=rng)\n            else:\n                params[Mutation_key] = Mutation_val[rng.randint(len(Mutation_val))]\n            yield params\n\n    def __len__(self):\n        \"\"\"Number of points that will be sampled.\"\"\"\n        if self._is_all_lists():\n            grid_size = len(ParameterGrid(self.param_distributions))\n            return min(self.lam, grid_size)\n        else:\n            return self.lam\n\nclass EvolutionaryStrategySearchCV(BaseSearchCV):\n    def __init__(\n        self,\n        estimator,\n        param_distributions,\n        n_iter=10,\n        random_state=None,\n        lam=3,\n        scoring=None,\n        n_jobs=None,\n        refit=True,\n        cv=None,\n        verbose=0,\n        pre_dispatch=\"2*n_jobs\",\n        error_score=np.nan,\n        return_train_score=True,\n    ):\n        # >> - estimator: This is assumed to implement the scikit-learn estimator interface.\n        # >> - param_distributions: Dictionary with parameters names ('str') as keys and distributions or lists of parameters to try. Distributions must provide a 'rvs' method for sampling (such as those from scipy.stats.distributions). If a list is given, it is sampled uniformly. If a list of dicts is given, first a dict is sampled uniformly, and then a parameter is sampled using that dict as above.\n        # >> - n_iter: Number of iterations.\n        # >> - random_state: The state of random seed.\n        # >> - warm_up: The number of times to randomly sample parameters in the initial state.\n        # >> - lam: The value of \\lambda in the 1+\\lambda evolution strategy, that is, the number of children in each iteration.\n        # >> - scoring: Strategy to evaluate the performance of the cross-validated model on the test set.\n        # >> - n_jobs: Number of jobs to run in parallel.\n        # >> - refit: Refit an estimator using the best found parameters on the whole dataset.\n        # >> - cv: Determines the cross-validation splitting strategy. Int, cross-validation generator or an iterable.\n        # >> - verbose: Controls the verbosity: the higher, the more messages.\n        # >> - pre_dispatch: Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process.\n        # >> - error_score: Value to assign to the score if an error occurs in estimator fitting.\n        # >> - return_train_score: If 'False', the 'cv_results_' attribute will not include training scores.\n        super().__init__(\n            estimator=estimator,\n            scoring=scoring,\n            n_jobs=n_jobs,\n            refit=refit,\n            cv=cv,\n            verbose=verbose,\n            pre_dispatch=pre_dispatch,\n            error_score=error_score,\n            return_train_score=return_train_score,\n        )\n        self.lam=lam\n        self.param_distributions = param_distributions\n        self.n_iter = n_iter\n        self.random_state = random_state\n\n    def fit(self, X, y=None, *, groups=None, **fit_params):\n        \"\"\"Run fit with all sets of parameters.\n\n        Parameters\n        ----------\n\n        X : array-like of shape (n_samples, n_features)\n            Training vector, where `n_samples` is the number of samples and\n            `n_features` is the number of features.\n\n        y : array-like of shape (n_samples, n_output) \\\n            or (n_samples,), default=None\n            Target relative to X for classification or regression;\n            None for unsupervised learning.\n\n        groups : array-like of shape (n_samples,), default=None\n            Group labels for the samples used while splitting the dataset into\n            train/test set. Only used in conjunction with a \"Group\" :term:`cv`\n            instance (e.g., :class:`~sklearn.model_selection.GroupKFold`).\n\n        **fit_params : dict of str -> object\n            Parameters passed to the ``fit`` method of the estimator.\n\n        Returns\n        -------\n        self : object\n            Instance of fitted estimator.\n        \"\"\"\n        estimator = self.estimator\n        refit_metric = \"score\"\n\n        if callable(self.scoring):\n            scorers = self.scoring\n        elif self.scoring is None or isinstance(self.scoring, str):\n            scorers = check_scoring(self.estimator, self.scoring)\n        else:\n            scorers = _check_multimetric_scoring(self.estimator, self.scoring)\n            self._check_refit_for_multimetric(scorers)\n            refit_metric = self.refit\n\n        X, y, groups = indexable(X, y, groups)\n        fit_params = _check_fit_params(X, fit_params)\n\n        cv_orig = check_cv(self.cv, y, classifier=is_classifier(estimator))\n        n_splits = cv_orig.get_n_splits(X, y, groups)\n\n        base_estimator = clone(self.estimator)\n\n        parallel = Parallel(n_jobs=self.n_jobs, pre_dispatch=self.pre_dispatch)\n\n        fit_and_score_kwargs = dict(\n            scorer=scorers,\n            fit_params=fit_params,\n            return_train_score=self.return_train_score,\n            return_n_test_samples=True,\n            return_times=True,\n            return_parameters=False,\n            error_score=self.error_score,\n            verbose=self.verbose,\n        )\n        results = {}\n        rng = check_random_state(self.random_state)\n        if isinstance(self.param_distributions, Mapping):\n            param_distributions = [self.param_distributions]\n        else:\n            param_distributions=self.param_distributions\n        dist = rng.choice(param_distributions)\n        # Always sort the keys of a dictionary, for reproducibility\n        items = sorted(dist.items())\n        self.best_params_ = dict()\n        for k, v in items:\n            if hasattr(v, \"rvs\"):\n                self.best_params_[k] = v.rvs(random_state=rng)\n            else:\n                self.best_params_[k] = v[rng.randint(len(v))]\n        all_candidate_params = []\n        all_out = []\n        all_more_results = defaultdict(list)\n        for _ in range(self.n_iter):\n            with parallel:\n                def evaluate_candidates(candidate_params, cv=None, more_results=None):\n                    cv = cv or cv_orig\n                    candidate_params = list(candidate_params)\n                    n_candidates = len(candidate_params)\n\n                    if self.verbose > 0:\n                        print(\n                            \"Fitting {0} folds for each of {1} candidates,\"\n                            \" totalling {2} fits\".format(\n                                n_splits, n_candidates, n_candidates * n_splits\n                            )\n                        )\n\n                    out = parallel(\n                        delayed(_fit_and_score)(\n                            clone(base_estimator),\n                            X,\n                            y,\n                            train=train,\n                            test=test,\n                            parameters=parameters,\n                            split_progress=(split_idx, n_splits),\n                            candidate_progress=(cand_idx, n_candidates),\n                            **fit_and_score_kwargs,\n                        )\n                        for (cand_idx, parameters), (split_idx, (train, test)) in product(\n                            enumerate(candidate_params), enumerate(cv.split(X, y, groups))\n                        )\n                    )\n\n                    if len(out) < 1:\n                        raise ValueError(\n                            \"No fits were performed. \"\n                            \"Was the CV iterator empty? \"\n                            \"Were there no candidates?\"\n                        )\n                    elif len(out) != n_candidates * n_splits:\n                        raise ValueError(\n                            \"cv.split and cv.get_n_splits returned \"\n                            \"inconsistent results. Expected {} \"\n                            \"splits, got {}\".format(n_splits, len(out) // n_candidates)\n                        )\n\n                    _warn_about_fit_failures(out, self.error_score)\n\n                    # For callable self.scoring, the return type is only know after\n                    # calling. If the return type is a dictionary, the error scores\n                    # can now be inserted with the correct key. The type checking\n                    # of out will be done in `_insert_error_scores`.\n                    if callable(self.scoring):\n                        _insert_error_scores(out, self.error_score)\n\n                    all_candidate_params.extend(candidate_params)\n                    all_out.extend(out)\n\n                    if more_results is not None:\n                        for key, value in more_results.items():\n                            all_more_results[key].extend(value)\n\n                    nonlocal results\n                    results = self._format_results(\n                        all_candidate_params, n_splits, all_out, all_more_results\n                    )\n                    print(all_candidate_params)\n                    print(all_out)\n                    print(results)\n                    return results\n\n                self._run_search(evaluate_candidates)\n\n            first_test_score = all_out[0][\"test_scores\"]\n            self.multimetric_ = isinstance(first_test_score, dict)\n\n            if callable(self.scoring) and self.multimetric_:\n                self._check_refit_for_multimetric(first_test_score)\n                refit_metric = self.refit\n\n\n            self.best_index_ = self._select_best_index(\n                self.refit, refit_metric, results\n            )\n            # With a non-custom callable, we can select the best score\n            # based on the best index\n            self.best_score_ = results[f\"mean_test_{refit_metric}\"][\n                self.best_index_\n            ]\n            self.best_params_ = results[\"params\"][self.best_index_]\n\n        if self.refit:\n            # we clone again after setting params in case some\n            # of the params are estimators as well.\n            self.best_estimator_ = clone(\n                clone(base_estimator).set_params(**self.best_params_)\n            )\n            refit_start_time = time.time()\n            if y is not None:\n                self.best_estimator_.fit(X, y, **fit_params)\n            else:\n                self.best_estimator_.fit(X, **fit_params)\n            refit_end_time = time.time()\n            self.refit_time_ = refit_end_time - refit_start_time\n\n            if hasattr(self.best_estimator_, \"feature_names_in_\"):\n                self.feature_names_in_ = self.best_estimator_.feature_names_in_\n\n        # Store the only scorer not as a dict for single metric evaluation\n        self.scorer_ = scorers\n\n        self.cv_results_ = results\n        self.n_splits_ = n_splits\n\n        return self\n\n    def _run_search(self, evaluate_candidates):\n        evaluate_candidates(\n            Evolve(\n                self.param_distributions, random_state=self.random_state,lam=self.lam,ancestors=self.best_params_\n            )\n        )\n"
  },
  {
    "path": "LAMDA_SSL/Search/MetaLearnerSearchCV.py",
    "content": "from sklearn.model_selection._search import BaseSearchCV,ParameterGrid\nfrom collections.abc import Mapping\nfrom sklearn.utils import check_random_state\nimport numpy as np\nimport time\nfrom sklearn.model_selection._validation import _fit_and_score\nfrom sklearn.model_selection._validation import _insert_error_scores\nfrom sklearn.model_selection._validation import _warn_about_fit_failures\nfrom collections import defaultdict\nfrom sklearn.model_selection._split import check_cv\nfrom sklearn.metrics._scorer import _check_multimetric_scoring\nfrom sklearn.metrics import check_scoring\nfrom sklearn.utils.validation import indexable, _check_fit_params\nfrom joblib import Parallel\nfrom itertools import product\nfrom sklearn.base import  is_classifier, clone\nfrom sklearn.utils.fixes import delayed\nfrom sklearn.model_selection._search import ParameterSampler\nfrom sklearn.svm import SVR\n\nclass MetaLearnerSearchCV(BaseSearchCV):\n    def __init__(\n        self,\n        estimator,\n        param_distributions,\n        meta_learner=SVR(),\n        n_iter=10,\n        random_state=None,\n        warm_up=2,\n        lam=3,\n        scoring=None,\n        n_jobs=None,\n        refit=True,\n        cv=None,\n        verbose=0,\n        pre_dispatch=\"2*n_jobs\",\n        error_score=np.nan,\n        return_train_score=True,\n    ):\n        # >> - estimator: This is assumed to implement the scikit-learn estimator interface.\n        # >> - param_distributions: Dictionary with parameters names ('str') as keys and distributions or lists of parameters to try. Distributions must provide a 'rvs' method for sampling (such as those from scipy.stats.distributions). If a list is given, it is sampled uniformly. If a list of dicts is given, first a dict is sampled uniformly, and then a parameter is sampled using that dict as above.\n        # >> - meta_learner: A meta-regressor for fitting parameters and scores.\n        # >> - n_iter: Number of iterations.\n        # >> - random_state: The state of random seed.\n        # >> - warm_up: The number of times to randomly sample parameters in the initial state.\n        # >> - lam: The number of parameter groups that need to be sampled for evaluation per iteration.\n        # >> - scoring: Strategy to evaluate the performance of the cross-validated model on the test set.\n        # >> - n_jobs: Number of jobs to run in parallel.\n        # >> - refit: Refit an estimator using the best found parameters on the whole dataset.\n        # >> - cv: Determines the cross-validation splitting strategy. Int, cross-validation generator or an iterable.\n        # >> - verbose: Controls the verbosity: the higher, the more messages.\n        # >> - pre_dispatch: Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process.\n        # >> - error_score: Value to assign to the score if an error occurs in estimator fitting.\n        # >> - return_train_score: If 'False', the 'cv_results_' attribute will not include training scores.\n        super().__init__(\n            estimator=estimator,\n            scoring=scoring,\n            n_jobs=n_jobs,\n            refit=refit,\n            cv=cv,\n            verbose=verbose,\n            pre_dispatch=pre_dispatch,\n            error_score=error_score,\n            return_train_score=return_train_score,\n        )\n        self.lam=lam\n        self.warm_up=warm_up\n        self.param_distributions = param_distributions\n        self.n_iter = n_iter\n        self.random_state = random_state\n        self.meta_learner=meta_learner\n\n    def _run_search(self, evaluate_candidates):\n        \"\"\"Search n_iter candidates from param_distributions\"\"\"\n        evaluate_candidates(\n            ParameterSampler(\n                self.param_distributions, self.warm_up, random_state=self.random_state\n            )\n        )\n\n    def fit(self, X, y=None, *, groups=None, **fit_params):\n        estimator = self.estimator\n        refit_metric = \"score\"\n\n        if callable(self.scoring):\n            scorers = self.scoring\n        elif self.scoring is None or isinstance(self.scoring, str):\n            scorers = check_scoring(self.estimator, self.scoring)\n        else:\n            scorers = _check_multimetric_scoring(self.estimator, self.scoring)\n            self._check_refit_for_multimetric(scorers)\n            refit_metric = self.refit\n\n        X, y, groups = indexable(X, y, groups)\n        fit_params = _check_fit_params(X, fit_params)\n\n        cv_orig = check_cv(self.cv, y, classifier=is_classifier(estimator))\n        n_splits = cv_orig.get_n_splits(X, y, groups)\n\n        base_estimator = clone(self.estimator)\n\n        parallel = Parallel(n_jobs=self.n_jobs, pre_dispatch=self.pre_dispatch)\n\n        fit_and_score_kwargs = dict(\n            scorer=scorers,\n            fit_params=fit_params,\n            return_train_score=self.return_train_score,\n            return_n_test_samples=True,\n            return_times=True,\n            return_parameters=False,\n            error_score=self.error_score,\n            verbose=self.verbose,\n        )\n\n        results = {}\n        all_candidate_params = []\n        all_out = []\n        all_more_results = defaultdict(list)\n\n        def evaluate_candidates(candidate_params, cv=None, more_results=None):\n            cv = cv or cv_orig\n            candidate_params = list(candidate_params)\n            n_candidates = len(candidate_params)\n\n            if self.verbose > 0:\n                print(\n                    \"Fitting {0} folds for each of {1} candidates,\"\n                    \" totalling {2} fits\".format(\n                        n_splits, n_candidates, n_candidates * n_splits\n                    )\n                )\n\n            out = parallel(\n                delayed(_fit_and_score)(\n                    clone(base_estimator),\n                    X,\n                    y,\n                    train=train,\n                    test=test,\n                    parameters=parameters,\n                    split_progress=(split_idx, n_splits),\n                    candidate_progress=(cand_idx, n_candidates),\n                    **fit_and_score_kwargs,\n                )\n                for (cand_idx, parameters), (split_idx, (train, test)) in product(\n                    enumerate(candidate_params), enumerate(cv.split(X, y, groups))\n                )\n            )\n\n            if len(out) < 1:\n                raise ValueError(\n                    \"No fits were performed. \"\n                    \"Was the CV iterator empty? \"\n                    \"Were there no candidates?\"\n                )\n            elif len(out) != n_candidates * n_splits:\n                raise ValueError(\n                    \"cv.split and cv.get_n_splits returned \"\n                    \"inconsistent results. Expected {} \"\n                    \"splits, got {}\".format(n_splits, len(out) // n_candidates)\n                )\n\n            _warn_about_fit_failures(out, self.error_score)\n\n            # For callable self.scoring, the return type is only know after\n            # calling. If the return type is a dictionary, the error scores\n            # can now be inserted with the correct key. The type checking\n            # of out will be done in `_insert_error_scores`.\n            if callable(self.scoring):\n                _insert_error_scores(out, self.error_score)\n\n            all_candidate_params.extend(candidate_params)\n            all_out.extend(out)\n\n            if more_results is not None:\n                for key, value in more_results.items():\n                    all_more_results[key].extend(value)\n\n            nonlocal results\n            results = self._format_results(\n                all_candidate_params, n_splits, all_out, all_more_results\n            )\n            return results\n\n        with parallel:\n            self._run_search(evaluate_candidates)\n\n        first_test_score = all_out[0][\"test_scores\"]\n        self.multimetric_ = isinstance(first_test_score, dict)\n\n        if callable(self.scoring) and self.multimetric_:\n            self._check_refit_for_multimetric(first_test_score)\n            refit_metric = self.refit\n        params = results['params']\n        score = results[f\"mean_test_{refit_metric}\"]\n        _X=[]\n        for _ in range(self.warm_up):\n            _X.append(list(params[_].values()))\n        _X=np.array(_X)\n        _y=score\n        for _ in range(self.n_iter):\n            self.meta_learner.fit(_X, _y)\n            condidate_params=list(ParameterSampler(\n                self.param_distributions, self.lam, random_state=self.random_state\n            ))\n            _test_X=[]\n            for _ in range(self.lam):\n                _test_X.append(list(condidate_params[_].values()))\n            _test_X=np.array(_test_X)\n            _pred_y=self.meta_learner.predict(_test_X)\n            idx=_pred_y.argmax()\n            _params=dict()\n            key_idx=0\n            for key in list(self.param_distributions.keys()):\n                _params[key]=_test_X[idx][key_idx]\n            evaluate_candidates([_params])\n            _X = np.concatenate((_X, np.expand_dims(_test_X[idx],axis=0)), axis=0)\n            _y= np.concatenate((_y,np.array([_pred_y[idx]])),axis=0)\n\n        first_test_score = all_out[0][\"test_scores\"]\n        self.multimetric_ = isinstance(first_test_score, dict)\n\n        if callable(self.scoring) and self.multimetric_:\n            self._check_refit_for_multimetric(first_test_score)\n            refit_metric = self.refit\n\n        self.best_index_ = self._select_best_index(\n            self.refit, refit_metric, results\n        )\n        # With a non-custom callable, we can select the best score\n        # based on the best index\n        self.best_score_ = results[f\"mean_test_{refit_metric}\"][\n            self.best_index_\n        ]\n        self.best_params_ = results[\"params\"][self.best_index_]\n\n        if self.refit:\n            # we clone again after setting params in case some\n            # of the params are estimators as well.\n            self.best_estimator_ = clone(\n                clone(base_estimator).set_params(**self.best_params_)\n            )\n            refit_start_time = time.time()\n            if y is not None:\n                self.best_estimator_.fit(X, y, **fit_params)\n            else:\n                self.best_estimator_.fit(X, **fit_params)\n            refit_end_time = time.time()\n            self.refit_time_ = refit_end_time - refit_start_time\n\n            if hasattr(self.best_estimator_, \"feature_names_in_\"):\n                self.feature_names_in_ = self.best_estimator_.feature_names_in_\n\n        # Store the only scorer not as a dict for single metric evaluation\n        self.scorer_ = scorers\n\n        self.cv_results_ = results\n        self.n_splits_ = n_splits\n\n        return self\n"
  },
  {
    "path": "LAMDA_SSL/Search/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Split/DataSplit.py",
    "content": "import numpy as np\nfrom sklearn.utils import _approximate_mode\nfrom LAMDA_SSL.utils import get_len\nfrom math import ceil\nfrom sklearn.utils import check_random_state\nfrom LAMDA_SSL.utils import to_numpy,get_indexing_method,indexing\n\ndef get_split_num(X,size_split=0.1):\n    len_X = get_len(X)\n    type_size_split = np.asarray(size_split).dtype.kind\n    if (\n        type_size_split == \"i\"\n        and (size_split >= len_X or size_split <= 0)\n        or type_size_split == \"f\"\n        and (size_split <= 0 or size_split >= 1)\n        ):\n        raise ValueError(\n            \"size_split={0} should be either positive and smaller\"\n            \" than the number of samples {1} or a float in the \"\n            \"(0, 1) range\".format(size_split, len_X)\n        )\n\n    if type_size_split == \"f\":\n        num_1 = ceil(size_split * len_X)\n    else:\n\n        num_1= size_split\n    num_2=len_X-num_1\n    return num_1,num_2\n\ndef get_split_index(y,num_1,num_2,stratified,shuffle,random_state=None):\n    rng=check_random_state(seed=random_state)\n    num_total=num_1+num_2\n    if stratified:\n        try:\n            y_arr=to_numpy(y)\n        except (AttributeError, TypeError):\n            y_arr = y\n        if y_arr.ndim == 2:\n            y_arr = np.array([\" \".join(row.astype(\"str\")) for row in y_arr])\n        classes, y_indices = np.unique(y_arr, return_inverse=True)\n        num_classes = classes.shape[0]\n        class_counts = np.bincount(y_indices)\n        if np.min(class_counts) < 2:\n            raise ValueError(\n                \"The least populated class in y has only 1\"\n                \" member, which is too few. The minimum\"\n                \" number of groups for any class cannot\"\n                \" be less than 2.\"\n            )\n\n        if num_1 < num_classes :\n            raise ValueError(\n                \"The num_1 = %d should be greater or \"\n                \"equal to the number of classes = %d\" % (num_1, num_classes)\n            )\n        if num_2< num_classes :\n            raise ValueError(\n                \"The num_2 = %d should be greater or \"\n                \"equal to the number of classes = %d\" % (num_2, num_classes)\n            )\n\n        # Find the sorted list of instances for each class:\n        # (np.unique above performs a sort, so code is O(n logn) already)\n        class_indices = np.split(\n            np.argsort(y_indices, kind=\"mergesort\"), np.cumsum(class_counts)[:-1]\n        )\n        n_i = _approximate_mode(class_counts, num_1, rng)\n        class_counts_remaining = class_counts - n_i\n        t_i = _approximate_mode(class_counts_remaining, num_2,rng)\n\n        ind_unlabeled = []\n        ind_labeled = []\n\n        for i in range(num_classes):\n            if shuffle:\n                permutation = rng.permutation(class_counts[i])\n            else:\n                permutation = np.arange(class_counts[i])\n            perm_indices_class_i = class_indices[i].take(permutation, mode=\"clip\")\n            ind_labeled.extend(perm_indices_class_i[: n_i[i]])\n            ind_unlabeled.extend(perm_indices_class_i[n_i[i] : n_i[i] + t_i[i]])\n        if shuffle:\n            ind_labeled = rng.permutation(ind_labeled)\n            ind_unlabeled = rng.permutation(ind_unlabeled)\n    else:\n        if shuffle:\n            permutation = rng.permutation(num_total)\n        else:\n            permutation = np.arange(num_total)\n        ind_labeled = permutation[:num_1]\n        ind_unlabeled = permutation[num_1 : (num_1+ num_2)]\n    return ind_labeled,ind_unlabeled\n\ndef DataSplit(stratified=True,shuffle=True,random_state=None, X=None, y=None,size_split=None):\n    # >> Parameter\n    # >> - stratified: Whether to stratify by classes.\n    # >> - shuffle: Whether to shuffle the data.\n    # >> - random_state: The random seed.\n    # >> - X: Samples of the data to be split.\n    # >> - y: Labels of the data to be split.\n    # >> - labeled_size: The scale or size of the labeled data.\n    num_1, num_2 = get_split_num(X, size_split)\n    ind_1, ind_2 = get_split_index(y=y, num_1=num_1, num_2=num_2,\n                                   stratified=stratified, shuffle=shuffle,\n                                   random_state=random_state)\n    X_indexing = get_indexing_method(X)\n    y_indexing = get_indexing_method(y)\n    X_1 = indexing(X, ind_1, X_indexing)\n    y_1 = indexing(y, ind_1, y_indexing)\n    X_2 = indexing(X, ind_2, X_indexing)\n    y_2 = indexing(y, ind_2, y_indexing)\n    return X_1, y_1, X_2, y_2\n\n\n        \n\n"
  },
  {
    "path": "LAMDA_SSL/Split/ViewSplit.py",
    "content": "import copy\n\nimport numpy as np\n\ndef ViewSplit(X,num_splits=2,axis=1,shuffle=True):\n    # >> Parameter\n    # >> - X: Samples of the data to be split.\n    # >> - num_splits: The number of views\n    # >> - axis: The axis of the dimension to be splited.\n    # >> - shuffle: Whether to shuffle the features.\n    shape=X.shape\n    range_shape=tuple(i for i in range(len(shape)))\n    pre=range_shape[:axis]\n    suf = range_shape[axis+1:]\n    num_features=shape[axis]\n    cur_array=np.arange(num_features)\n    num_features_view=num_features//num_splits\n    mod=num_features%num_splits\n    idx=[]\n    for _ in range(num_splits):\n        if _ < mod:\n            cur_size=num_features_view+1\n        else:\n            cur_size = num_features_view\n        if shuffle is True:\n            cur_idx = np.random.choice(cur_array, size=cur_size, replace=False)\n        else:\n            cur_idx= cur_array[:cur_size]\n        cur_array = np.array([i for i in cur_array if i not in cur_idx])\n        idx.append(cur_idx)\n    _X=copy.copy(X)\n    _X=_X.transpose(tuple([axis])+pre+suf)\n    result = []\n    for cur_idx in idx:\n        cur_X=_X[cur_idx]\n        cur_X=cur_X.transpose(range_shape[1:axis+1]+tuple([0])+range_shape[axis+1:])\n        result.append(cur_X)\n    return result\n\n\n\n"
  },
  {
    "path": "LAMDA_SSL/Split/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Transform/Graph/GCNNorm.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torch_geometric.transforms as gt\nclass GCNNorm(Transformer):\n    def __init__(self,add_self_loops=True):\n        # >> Parameter:\n        # >> - add_self_loops: Whether to add self loops.\n        super().__init__()\n        self.GCNNorm=gt.GCNNorm(add_self_loops=add_self_loops)\n\n    def transform(self,X):\n        X=self.GCNNorm(X)\n        return X"
  },
  {
    "path": "LAMDA_SSL/Transform/Graph/GDC.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torch_geometric.transforms as gt\nclass GDC(Transformer):\n    def __init__(self,self_loop_weight=1, normalization_in='sym',\n                 normalization_out='col',\n                 diffusion_kwargs=dict(method='ppr', alpha=0.15),\n                 sparsification_kwargs=dict(method='threshold',avg_degree=64),\n                 exact=True):\n        # >> Parameter:\n        # >> - self_loop_weight: Weight of the added self-loop. Set to None to add no self-loops.\n        # >> - normalization_in: Normalization of the transition matrix on the original (input) graph. Possible values: \"sym\", \"col\", and \"row\"`.\n        # >> - normalization_out: Normalization of the transition matrix on the transformed GDC (output) graph. Possible values: \"sym\", \"col\", and \"row\"`.\n        # >> - diffusion_kwargs: Dictionary containing the parameters for diffusion.\n        # >> - sparsification_kwargs: Dictionary containing the parameters for sparsification.\n        # >> - exact: Whether to accurately calculate the diffusion matrix.\n        super().__init__()\n        self.gdc=gt.GDC(self_loop_weight=self_loop_weight,normalization_in=normalization_in,\n                        normalization_out=normalization_out,diffusion_kwargs=diffusion_kwargs,\n                        sparsification_kwargs=sparsification_kwargs,exact=exact)\n\n    def transform(self,X):\n        X=self.gdc(X)\n        return X\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Graph/NormalizeFeatures.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torch_geometric.transforms as gt\n\nclass NormalizeFeatures(Transformer):\n    def __init__(self,attrs=[\"x\"]):\n        # >> Parameter:\n        # >> - attrs: Properties that require regularization.\n        super().__init__()\n        self.attrs=attrs\n        self.normalize=gt.NormalizeFeatures(attrs)\n\n\n    def transform(self,X):\n        if X is not None:\n            X=self.normalize(X)\n            return X\n        else:\n            raise ValueError('No data to augment')"
  },
  {
    "path": "LAMDA_SSL/Transform/Graph/SVDFeatureReduction.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torch_geometric.transforms as gt\nclass SVDFeatureReduction(Transformer):\n    def __init__(self,out_channels):\n        # >> Parameter:\n        # >> - out_channels: The dimensionlity of node features after reduction.\n        super().__init__()\n        self.svd_feature_reduction=gt.SVDFeatureReduction(out_channels=out_channels)\n\n    def transform(self,X):\n        X=self.svd_feature_reduction(X)\n        return X\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Graph/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Transform/Tabular/MaxAbsScaler.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nclass MaxAbsScaler(Transformer):\n    def __init__(self,max_abs=None):\n        super().__init__()\n        # >> Parameter:\n        # >> - max_abs: The max abs value.\n        self.max_abs=max_abs\n\n    def transform(self,X):\n        max_abs=X.abs().max() if self.max_abs is None else self.max_abs\n        return X/max_abs"
  },
  {
    "path": "LAMDA_SSL/Transform/Tabular/MinMaxScaler.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nclass MinMaxScaler(Transformer):\n    def __init__(self,min_val=None,max_val=None):\n        super().__init__()\n        # >> Parameter:\n        # >> - min_val: The minimum value.\n        # >> - max_val: The maximum value.\n        self.min_val=min_val\n        self.max_val=max_val\n\n    def transform(self,X):\n        min_val=X.min() if self.min_val is None else self.min_val\n        max_val = X.max() if self.max_val is None else self.max_val\n        return (X-min_val)/(max_val-min_val)"
  },
  {
    "path": "LAMDA_SSL/Transform/Tabular/StandarScaler.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nclass StandardScaler(Transformer):\n    def __init__(self,mean=None,std=None):\n        super().__init__()\n        # >> Parameter:\n        # >> - mean: The value of mean.\n        # >> - std: The value of standard deviation.\n        self.mean=mean\n        self.std=std\n\n    def transform(self,X):\n        mean=X.mean() if self.mean is None else self.mean\n        std = X.std() if self.std is None else self.std\n        return (X-mean)/std\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Tabular/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Transform/Text/AdjustLength.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nfrom LAMDA_SSL.Transform.Text.PadSequence import PadSequence\r\nfrom LAMDA_SSL.Transform.Text.Truncate import Truncate\r\nclass AdjustLength(Transformer):\r\n    def __init__(self,length=300,pad_val=None,pos=0):\r\n        # >> Parameter:\r\n        # >> - length: Length of adjusted sentence.\r\n        # >> - pad_val: The padding value for insufficient length of text.\r\n        # >> - pos；If the sentence is too long and needs to be cut, this parameter specifies the position to start cutting.\r\n        super().__init__()\r\n        self.length=length\r\n        self.pad=PadSequence(self.length,pad_val)\r\n        self.truncate=Truncate(length,pos)\r\n\r\n    def transform(self,X):\r\n        if len(X)<self.length:\r\n            X=self.pad(X)\r\n        else:\r\n            X=self.truncate(X)\r\n        return X"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/AutoTokenizer.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nfrom LAMDA_SSL.Transform.Text.PadSequence import PadSequence\r\nfrom LAMDA_SSL.Transform.Text.Truncate import Truncate\r\nfrom transformers import AutoTokenizer as AT\r\n\r\nclass AutoTokenizer(Transformer):\r\n    def __init__(self,model_name='hfl/chinese-roberta-wwm-ext',padding='max_length',\r\n                 truncation=True,max_length=256,return_tensors='pt',local_files_only=False):\r\n        super().__init__()\r\n        self.local_files_only=local_files_only\r\n        self.tokenizer=AT.from_pretrained(model_name,local_files_only=self.local_files_only)\r\n        self.padding=padding\r\n        self.truncation=truncation\r\n        self.max_length=max_length\r\n        self.return_tensors=return_tensors\r\n\r\n    def transform(self,X):\r\n        X=self.tokenizer(X, padding=self.padding, truncation=self.truncation, \r\n            max_length=self.max_length, return_tensors=self.return_tensors)\r\n        return X\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/CharNGram.py",
    "content": "from torchtext import vocab\r\nfrom LAMDA_SSL.Base.Transformer import Transformer\r\nimport torch\r\n\r\nclass CharNGram(Transformer):\r\n    def __init__(self,lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>',cache=None):\r\n        # >> Parameter:\r\n        # >> - lower_case_backup: Whether to convert all to lowercase when looking up words.\r\n        # >> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_token: The default padding token.\r\n        # >> - unk_token: The default token represents unknown words.\r\n        super().__init__()\r\n        self.vec=vocab.CharNGram(cache=cache)\r\n        self.unk_init = torch.Tensor.zero_ if unk_init is None else unk_init\r\n        self.pad_init = torch.Tensor.zero_ if pad_init is None else pad_init\r\n        self.lower_case_backup=lower_case_backup\r\n        self.vec.stoi[pad_token]=self.vec.vectors.shape[0]\r\n        self.vec.stoi[unk_token] = self.vec.vectors.shape[0]+1\r\n        self.vec.vectors=torch.cat([self.vec.vectors,self.pad_init(torch.Tensor(self.vec.vectors.shape[1])),\r\n                                    self.unk_init(torch.Tensor(self.vec.vectors.shape[1]))],dim=0)\r\n\r\n    def transform(self,X):\r\n        if isinstance(X,tuple):\r\n            X=list(X)\r\n        if isinstance(X,list):\r\n            return self.vec.get_vecs_by_tokens(X,lower_case_backup=self.lower_case_backup)\r\n        else:\r\n            return self.vec[X]\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/FastText.py",
    "content": "from torchtext import vocab\r\nfrom LAMDA_SSL.Base.Transformer import Transformer\r\nimport torch\r\n\r\nclass FastText(Transformer):\r\n    def __init__(self, language=\"en\",lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>',cache=None):\r\n        # >> Parameter:\r\n        # >> - language: Language type.\r\n        # >> - lower_case_backup: Whether to convert all to lowercase when looking up words.\r\n        # >> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_token: The default padding token.\r\n        # >> - unk_token: The default token represents unknown words.\r\n        super().__init__()\r\n        self.vec=vocab.FastText(language=language,cache=cache)\r\n        self.unk_init = torch.Tensor.zero_ if unk_init is None else unk_init\r\n        self.pad_init = torch.Tensor.zero_ if pad_init is None else pad_init\r\n        self.lower_case_backup=lower_case_backup\r\n        self.vec.stoi[pad_token]=self.vec.vectors.shape[0]\r\n        self.vec.stoi[unk_token] = self.vec.vectors.shape[0]+1\r\n        self.vec.vectors=torch.cat([self.vec.vectors,self.pad_init(torch.Tensor(self.vec.vectors.shape[1])),\r\n                                    self.unk_init(torch.Tensor(self.vec.vectors.shape[1]))],dim=0)\r\n    def transform(self,X):\r\n        if isinstance(X,tuple):\r\n            X=list(X)\r\n        if isinstance(X,list):\r\n            return self.vec.get_vecs_by_tokens(X,lower_case_backup=self.lower_case_backup)\r\n        else:\r\n            return self.vec[X]\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/GloVe.py",
    "content": "from torchtext import vocab\r\nfrom LAMDA_SSL.Base.Transformer import Transformer\r\nimport torch\r\n\r\nclass Glove(Transformer):\r\n    def __init__(self,name=\"840B\", dim=300,lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>',cache=None):\r\n        # >> Parameter:\r\n        # >> - name: The name of the word vector.\r\n        # >> - dim: The dimension of the word vector.\r\n        # >> - lower_case_backup: Whether to convert all to lowercase when looking up words.\r\n        # >> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_token: The default padding token.\r\n        # >> - unk_token: The default token represents unknown words.\r\n        super().__init__()\r\n        self.vec=vocab.GloVe(name,dim,cache=cache)\r\n        self.unk_init = torch.Tensor.zero_ if unk_init is None else unk_init\r\n        self.pad_init = torch.Tensor.zero_ if pad_init is None else pad_init\r\n        self.lower_case_backup=lower_case_backup\r\n        self.vec.stoi[pad_token]=self.vec.vectors.shape[0]\r\n        self.vec.stoi[unk_token] = self.vec.vectors.shape[0]+1\r\n        self.vec.vectors=torch.cat([self.vec.vectors,self.pad_init(torch.Tensor(self.vec.vectors.shape[1])).unsqueeze(0),\r\n                                    self.unk_init(torch.Tensor(self.vec.vectors.shape[1])).unsqueeze(0)],dim=0)\r\n\r\n    def transform(self,X):\r\n        if isinstance(X,tuple):\r\n            X=list(X)\r\n        if isinstance(X,list):\r\n            return self.vec.get_vecs_by_tokens(X,lower_case_backup=self.lower_case_backup)\r\n        else:\r\n            return self.vec[X]\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/Lcut.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nfrom LAMDA_SSL.Transform.Text.PadSequence import PadSequence\r\nfrom LAMDA_SSL.Transform.Text.Truncate import Truncate\r\nimport jieba\r\n\r\nclass Lcut(Transformer):\r\n    def __init__(self):\r\n        super().__init__()\r\n\r\n    def transform(self,X):\r\n        X = jieba.lcut(X)\r\n        return X\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/PadSequence.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nclass PadSequence(Transformer):\r\n    def __init__(self,length=300,pad_val=None):\r\n        # > Parameter:\r\n        # >> - length: The length of the text after padding.\r\n        # >> - pad_val: The padding value for insufficient length of text.\r\n        super(PadSequence, self).__init__()\r\n        self.pad_val=pad_val\r\n        self.length=length\r\n    def transform(self,X):\r\n        if self.pad_val is None:\r\n            if isinstance(X[0],str):\r\n                pad_val=\"<pad>\"\r\n            else:\r\n                pad_val=type(X[0])(0)\r\n        else:\r\n            pad_val=self.pad_val\r\n        cur_length=len(X)\r\n        pad_length=int(max(0,self.length-cur_length))\r\n        if isinstance(X,list):\r\n            X=list(X)\r\n        for _ in range(pad_length):\r\n            X.append(pad_val)\r\n        return X"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/Split.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\n\r\nclass Split(Transformer):\r\n    def __init__(self):\r\n        super().__init__()\r\n\r\n    def transform(self,X):\r\n        X = X.split()\r\n        return X\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/SynonymsReplacement.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nfrom LAMDA_SSL.Transform.Text.PadSequence import PadSequence\r\nfrom LAMDA_SSL.Transform.Text.Truncate import Truncate\r\nfrom synonyms import synonyms\r\nimport copy\r\nimport random\r\ndef synonym_replacement(tokens, n=10):\r\n    new_tokens = copy.copy(tokens) # 复制分词结果，以免改变原始数据\r\n    n=min(n,len(new_tokens))\r\n    random_index=random.sample(range(len(new_tokens)), n)\r\n    for i in range(n):\r\n        rand_word_index = random_index[i]\r\n        words = synonyms.nearby(tokens[rand_word_index])[0]\r\n        if len(words)>=1:\r\n            new_word = words[1]\r\n            new_tokens[rand_word_index] = new_word\r\n    return ''.join(new_tokens)\r\n\r\nclass SynonymsReplacement(Transformer):\r\n    def __init__(self,n=10):\r\n        super().__init__()\r\n        self.n=n\r\n\r\n    def transform(self,X):\r\n        X=synonym_replacement(X,self.n)\r\n        return X\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/Tokenizer.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nfrom torchtext.data.utils import get_tokenizer\r\n\r\nclass Tokenizer(Transformer):\r\n    def __init__(self,tokenizer='basic_english',language='en'):\r\n        # >> Parameter:\r\n        # >> - tokenizer: Function name for word segmentation, such as basic_english, spacy, moses, toktok, revtok, subword, etc.\r\n        # >> - language: The language of the text.\r\n        super(Tokenizer, self).__init__()\r\n        self.tokenizer=tokenizer\r\n        self.language=language\r\n        self.transformer=get_tokenizer(self.tokenizer)\r\n\r\n    def transform(self,X):\r\n        X=self.transformer(X)\r\n        return X"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/Truncate.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\r\nclass Truncate(Transformer):\r\n    def __init__(self,length=300,pos=0):\r\n        # >> Paraameter:\r\n        # >> - length: The length of the truncated text .\r\n        # >> - pos: The position to start truncating.\r\n        super().__init__()\r\n        self.length=length\r\n        self.pos=pos\r\n\r\n    def transform(self,X):\r\n\r\n        assert len(X)>=self.pos+self.length\r\n\r\n        return X[self.pos:self.pos+self.length]\r\n\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/Vectors.py",
    "content": "from torchtext import vocab\r\nfrom LAMDA_SSL.Base.Transformer import Transformer\r\nimport torch\r\nclass Vectors(Transformer):\r\n    def __init__(self,name='840B', cache=None, url=None, unk_init=None,pad_init=None, max_vectors=None,lower_case_backup=True,\r\n                 pad_token='<pad>',unk_token='<unk>'):\r\n        # >> Parameter:\r\n        # >> - name: The name of the word vector.\r\n        # >> - cache: Directory for cached vectors。\r\n        # >> - url: The download address of the word vector.\r\n        # >> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\r\n        # >> - max_vectors: The maximum number of word vectors.\r\n        # >> - lower_case_backup: Whether to convert all to lowercase when looking up words.\r\n        # >> - pad_token: The default padding token.\r\n        # >> - unk_token: The default token represents unknown words.\r\n        super(Vectors, self).__init__()\r\n        self.vec=vocab.Vectors(name,cache,url,unk_init,max_vectors)\r\n        self.unk_init = torch.Tensor.zero_ if unk_init is None else unk_init\r\n        self.pad_init = torch.Tensor.zero_ if pad_init is None else pad_init\r\n        self.lower_case_backup=lower_case_backup\r\n        self.vec.stoi[pad_token]=self.vec.vectors.shape[0]\r\n        self.vec.stoi[unk_token] = self.vec.vectors.shape[0]+1\r\n        self.vec.vectors=torch.cat([self.vec.vectors,self.pad_init(torch.Tensor(self.vec.vectors.shape[1])),\r\n                                    self.unk_init(torch.Tensor(self.vec.vectors.shape[1]))],dim=0)\r\n\r\n\r\n\r\n    def transform(self,X):\r\n        if isinstance(X,tuple):\r\n            X=list(X)\r\n        if isinstance(X,list):\r\n            if isinstance(X[0],str):\r\n                return self.vec.get_vecs_by_tokens(X,lower_case_backup=self.lower_case_backup)\r\n            else:\r\n                indices = [self.vec.vectors[idx] for idx in X]\r\n                return torch.stack(indices)\r\n        else:\r\n            if isinstance(X[0],str):\r\n                return self.vec[X]\r\n            else:\r\n                return self.vec.vectors[X]\r\n\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/Vocab.py",
    "content": "from torchtext.vocab import vocab\r\nfrom collections import Counter,OrderedDict\r\nfrom LAMDA_SSL.Base.Transformer import Transformer\r\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\r\n\r\nclass Vocab(Transformer):\r\n    def __init__(self,word_vocab=None,vectors=None,text=None,min_freq=1,specials=[\"<unk>\",\"<pad>\"],special_first=True,default_index=None,tokenizer=None):\r\n        # >> Parameter:\r\n        # >> - word_vocab: A map that converts words to indexes.\r\n        # >> - vectors: Word vectors.\r\n        # >> - text: When word_vocab is None, use text to create a mapping table.\r\n        # >> - min_freq: The minimum frequency required for a word to be used as a token in the word_vocab. It is valid when word_vocab is None and a mapping table needs to be constructed.\r\n        # >> - specials: List of special characters.\r\n        # >> - special_first: Whether to put special characters at the top of the mapping table.\r\n        # >> - default_index: The default value that should be used when converting a word to an index if it cannot be converted.\r\n        # >> - tokenizer: The word segmentation method used.\r\n        super(Vocab, self).__init__()\r\n        self.text=text\r\n        self.specials=specials\r\n        self.min_freq=min_freq\r\n        self.special_first=special_first\r\n        self.word_vocab=word_vocab\r\n        self.vectors=vectors\r\n        self.tokenizer=Tokenizer('basic_english','en') if tokenizer is None else tokenizer\r\n        if self.vectors is not None:\r\n            self.word_vocab=self.vectors.stoi\r\n            self.default_index = self.word_vocab[\"<unk>\"] if default_index is None else default_index\r\n        elif self.word_vocab is None:\r\n            counter = Counter()\r\n            for item in text:\r\n                if isinstance(item ,str):\r\n                    item=self.tokenizer.fit_transform(item)\r\n                counter.update(item)\r\n            if specials is not None:\r\n                for tok in specials:\r\n                    del counter[tok]\r\n            sorted_by_freq_tuples = sorted(counter.items(), key=lambda x: x[0])\r\n            sorted_by_freq_tuples.sort(key=lambda x: x[1], reverse=True)\r\n            ordered_dict = OrderedDict(sorted_by_freq_tuples)\r\n            if specials is not None:\r\n                if special_first:\r\n                    specials = specials[::-1]\r\n                for symbol in specials:\r\n                    ordered_dict.update({symbol: min_freq})\r\n                    ordered_dict.move_to_end(symbol, last=not special_first)\r\n            self.word_vocab = vocab(ordered_dict, min_freq=min_freq)\r\n            self.default_index = self.word_vocab[\"<unk>\"] if default_index is None else default_index\r\n            self.word_vocab.set_default_index(self.default_index)\r\n\r\n\r\n\r\n    def transform(self,X):\r\n        if self.vectors is not None:\r\n            return [self.word_vocab[item] if item in self.word_vocab.keys() else self.default_index for item in X]\r\n        return [self.word_vocab[item] for item in X]\r\n\r\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Text/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Transform/ToImage.py",
    "content": "import torch\n\nfrom LAMDA_SSL.Base.Transformer import Transformer\nimport PIL\nimport numpy as np\n\n\nclass ToImage(Transformer):\n\n    def __init__(self,channels=3,channels_first=False):\n        # > - Parameter:\n        # >> - channels: The number of channels of input images.\n        # >> - channels_first: Whether the number of channels is before the image size.\n        super(ToImage, self).__init__()\n        self.channels=channels\n        self.channels_first=channels_first\n\n    def transform(self,X):\n        if isinstance(X,torch.Tensor):\n            X=X.numpy()\n        if self.channels_first is True and len(X.shape)==3:\n            X=X.transpose((1,2,0))\n        if isinstance(X, np.ndarray):\n            X = PIL.Image.fromarray(X)\n        return X"
  },
  {
    "path": "LAMDA_SSL/Transform/ToNumpy.py",
    "content": "from LAMDA_SSL.utils import to_numpy,is_pandas_ndframe,is_torch_data_type\nimport numpy as np\n\nfrom LAMDA_SSL.Base.Transformer import Transformer\nclass ToNumpy(Transformer):\n    def __init__(self):\n        super().__init__()\n\n    def transform(self,X):\n        if isinstance(X, np.ndarray):\n            return X\n        if isinstance(X, dict):\n            return np.array(to_numpy(val) for key, val in X.items())\n        if is_pandas_ndframe(X):\n            return X.values\n        if isinstance(X, (tuple, list)):\n            return np.array(X)\n        if not is_torch_data_type(X):\n            raise TypeError(\"Cannot convert this data type to a numpy array.\")\n        if X.is_cuda:\n            X = X.cpu()\n        if X.requires_grad:\n            X = X.detach()\n        return X.numpy()"
  },
  {
    "path": "LAMDA_SSL/Transform/ToTensor.py",
    "content": "import torch\nimport PIL\nimport numpy as np\nfrom LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms as tvt\nclass ToTensor(Transformer):\n    def __init__(self,dtype=None,image=False):\n        # > - Parameter:\n        # >> - dtype: The dtype of Tensor.\n        # >> - image: Whether the X is a image.\n        super().__init__()\n        self.dtype=dtype\n        self.image=image\n\n    def transform(self,X):\n        if self.image is True:\n            if isinstance(X, np.ndarray):\n                X = PIL.Image.fromarray(X)\n            if isinstance(X,PIL.Image.Image):\n                X=tvt.ToTensor()(X)\n            if self.dtype == 'float' or self.dtype=='float32':\n                X=X.float()\n            elif self.dtype == 'double' or self.dtype == 'float64':\n                X=X.double()\n            elif self.dtype == 'uint8' or self.dtype == 'uint' or self.dtype == 'byte':\n                X=X.byte()\n            elif self.dtype == 'int8' or self.dtype == 'char':\n                X =X.char()\n            elif self.dtype == 'int16' or self.dtype == 'short':\n                X =X.short()\n            elif self.dtype == 'int32' or self.dtype == 'int':\n                X =X.int()\n            elif self.dtype == 'int64' or self.dtype == 'long':\n                X =X.long()\n        else:\n            if self.dtype == 'float' or self.dtype=='float32':\n                X=torch.FloatTensor(X)\n            elif self.dtype == 'double' or self.dtype=='float64':\n                X=torch.DoubleTensor(X)\n            elif self.dtype == 'uint8' or self.dtype=='uint' or self.dtype=='byte':\n                X=torch.ByteTensor(X)\n            elif self.dtype == 'int8' or self.dtype=='char':\n                X=torch.CharTensor(X)\n            elif self.dtype == 'int16'or self.dtype=='short':\n                X = torch.ShortTensor(X)\n            elif self.dtype == 'int32'or self.dtype=='int':\n                X = torch.IntTensor(X)\n            elif self.dtype == 'int64'or self.dtype=='long':\n                X = torch.LongTensor(X)\n            else:\n                X=torch.Tensor(X)\n        return X\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Vision/Normalization.py",
    "content": "from torchvision.transforms import transforms\nfrom LAMDA_SSL.Base.Transformer import Transformer\nclass Normalization(Transformer):\n    def __init__(self,mean=None,std=None):\n        super().__init__()\n        # > - Parameter:\n        # >> - mean: The mean of normalization.\n        # >> - std: The standard deviation of normalization.\n        self.mean=mean\n        self.std=std\n        self.normalize=transforms.Normalize(mean=self.mean, std=self.std)\n\n    def transform(self,X):\n        X=self.normalize(X.float())\n        return X\n"
  },
  {
    "path": "LAMDA_SSL/Transform/Vision/Resize.py",
    "content": "from LAMDA_SSL.Base.Transformer import Transformer\nimport torchvision.transforms.functional as F\nimport PIL\nimport numpy as np\nfrom torchvision.transforms import InterpolationMode\nfrom LAMDA_SSL.utils import partial\nclass Resize(Transformer):\n    def __init__(self,size, interpolation = InterpolationMode.BILINEAR,\n           max_size = None, antialias = None):\n        # > - Parameter:\n        # > - size: Desired output size. If size is a sequence like (h, w), the output size\n        #           will be matched to this. If size is an int, the smaller edge of the image\n        #           will be matched to this number maintaining the aspect ratio.\n        # > - interpolation: Desired interpolation enum defined by 'torchvision.transforms.InterpolationMode'.\n        # > - max_size: The maximum allowed for the longer edge of the resized image: if the\n        #           longer edge of the image is greater than 'max_size`' after being resized\n        #           according to 'size', then the image is resized again so that the longer\n        #           edge is equal to 'max_size'.\n        # > - antialias: antialias flag. If 'img' is PIL Image, the flag is ignored and anti-alias\n        #           is always used. If 'img' is Tensor, the flag is False by default and can be set\n        #           to True for 'InterpolationMode.BILINEAR' only mode. This can help making the output\n        #           for PIL images and tensors closer.\n        super().__init__()\n        self.resize=partial(F.resize,size=size,interpolation=interpolation,max_size=max_size,antialias=antialias)\n\n    def transform(self,X):\n        if isinstance(X,np.ndarray):\n            X=PIL.Image.fromarray(X)\n        X = self.resize(X)\n        return X"
  },
  {
    "path": "LAMDA_SSL/Transform/Vision/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/Transform/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/__init__.py",
    "content": ""
  },
  {
    "path": "LAMDA_SSL/utils.py",
    "content": "import copy\nfrom distutils.version import LooseVersion\nfrom functools import partial\nfrom numbers import Number\nfrom reprlib import recursive_repr\nimport sklearn\nimport torch\nfrom torch.utils.data import dataset\nimport numpy as np\nfrom scipy import sparse\nfrom torch.nn.utils.rnn import PackedSequence\nimport torch.nn as nn\n\n\nif LooseVersion(sklearn.__version__) >= '0.22.0':\n    from sklearn.utils import _safe_indexing as safe_indexing\nelse:\n    from sklearn.utils import safe_indexing\n\ndef is_pandas_ndframe(x):\n    return hasattr(x, 'iloc')\n\ndef indexing_none(data, i):\n    return None\n\n\ndef indexing_dict(data, i):\n    return {k: v[i] for k, v in data.items()}\n\n\ndef indexing_list_tuple_of_data(data, i, indexings=None):\n    if not indexings:\n        return [indexing(x, i) for x in data]\n    return [indexing(x, i, ind)\n            for x, ind in zip(data, indexings)]\n\ndef indexing_sparse(data,i):\n    data=copy.copy(data)\n    data = data.toarray().squeeze(0)\n    return data[i]\n\ndef indexing_ndframe(data, i):\n    if hasattr(data, 'iloc'):\n        data=data.copy(data)\n        data = {k: data[k].values.reshape(-1, 1) for k in data}\n        return data.iloc[i]\n    return indexing_dict(data, i)\n\n\ndef indexing_other(data, i):\n    if isinstance(i, (int, np.integer, slice, tuple)):\n        return data[i]\n    return safe_indexing(data, i)\n\ndef indexing_dataset(data,i):\n    return data[i]\n\n\n\n\ndef get_indexing_method(data):\n    if data is None:\n        return indexing_none\n    if isinstance(data, torch.utils.data.Dataset):\n        return indexing_dataset\n\n    if isinstance(data, dict):\n        return indexing_dict\n\n    if is_sparse(data):\n        return indexing_sparse\n\n    if isinstance(data, (list, tuple)):\n        try:\n            if isinstance(data[0],(Number,str)):\n                raise TypeError('Can not index data!')\n            indexing(data[0], 0)\n            indexings = [get_indexing_method(x) for x in data]\n            return partial(indexing_list_tuple_of_data, indexings=indexings)\n        except TypeError:\n            return indexing_other\n\n    if is_pandas_ndframe(data):\n        return indexing_ndframe\n\n    return indexing_other\n\n\ndef normalize_numpy_indices(i):\n    if isinstance(i, np.ndarray):\n        if i.dtype == bool:\n            i = tuple(j.tolist() for j in i.nonzero())\n        elif i.dtype == int:\n            i = i.tolist()\n    return i\n\n\ndef indexing(data, i, indexing_method=None):\n\n    i = normalize_numpy_indices(i)\n\n    if indexing_method is not None:\n        return indexing_method(data, i)\n\n    return get_indexing_method(data)(data, i)\n\ndef flatten(arr):\n    for item in arr:\n        if isinstance(item, (tuple, list, dict)):\n            yield from flatten(item)\n        else:\n            yield item\n\ndef apply_to_data(data, func, unpack_dict=False):\n    apply_ = partial(apply_to_data, func=func, unpack_dict=unpack_dict)\n    if isinstance(data, dict):\n        if unpack_dict:\n            return [apply_(v) for v in data.values()]\n        return {k: apply_(v) for k, v in data.items()}\n\n    if isinstance(data, (list, tuple)):\n        try:\n            return [apply_(x) for x in data]\n        except TypeError:\n            return func(data)\n    return func(data)\n\ndef is_sparse(x):\n    try:\n        return sparse.issparse(x) or x.is_sparse\n    except AttributeError:\n        return False\n\ndef _len(data):\n    if isinstance(data,(Number,str)):\n        raise TypeError('Can not get the lengeth of data!')\n    if data is None:\n        return 0\n    elif isinstance(data,torch.utils.data.Dataset):\n        return data.__len__()\n    elif is_sparse(data):\n        return data.shape[0]\n    else:\n        return len(data)\n\ndef get_len(data):\n    lens = [apply_to_data(data, _len, unpack_dict=True)]\n    lens = list(flatten(lens))\n    len_set = set(lens)\n    if len(len_set) != 1:\n        raise ValueError(\"Dataset does not have consistent lengths.\")\n    return list(len_set)[0]\n\ndef is_torch_data_type(x):\n    # pylint: disable=protected-access\n    return isinstance(x, (torch.Tensor, PackedSequence))\n\ndef to_device(X, device):\n\n    if device is None:\n        return X\n\n    if isinstance(X, dict):\n        return {key: to_device(val, device) for key, val in X.items()}\n\n    if isinstance(X, (tuple, list)) and (type(X) != PackedSequence):\n        return type(X)(to_device(x, device) for x in X)\n\n    if isinstance(X, torch.distributions.distribution.Distribution):\n        return X\n\n    return X.to(device)\n\n# def to_tensor(X, device=None, accept_sparse=False):\n#     to_tensor_ = partial(to_tensor, device=device)\n#     if is_torch_data_type(X):\n#         return to_device(X, device)\n#     if isinstance(X, dict):\n#         return {key: to_tensor_(val) for key, val in X.items()}\n#     if isinstance(X, (list, tuple)):\n#         try:\n#             indexing(X[0],0)\n#             return [to_tensor_(x) for x in X]\n#         except:\n#             return torch.as_tensor(np.array(X), device=device)\n#     if np.isscalar(X):\n#         return torch.as_tensor(X, device=device)\n#     if isinstance(X, Sequence):\n#         return torch.as_tensor(np.array(X), device=device)\n#     if isinstance(X, np.ndarray):\n#         return torch.as_tensor(X, device=device)\n#     if sparse.issparse(X):\n#         if accept_sparse:\n#             return torch.sparse_coo_tensor(\n#                 X.nonzero(), X.data, size=X.shape).to(device)\n#         raise TypeError(\"Sparse matrices are not supported. Set \"\n#                         \"accept_sparse=True to allow sparse matrices.\")\n#\n#     raise TypeError(\"Cannot convert this data type to a torch tensor.\")\n\n\ndef to_numpy(X):\n    if isinstance(X, np.ndarray):\n        return X\n    if isinstance(X, dict):\n        return np.array(to_numpy(val) for key, val in X.items())\n    if is_pandas_ndframe(X):\n        return X.values\n    if isinstance(X, (tuple, list)):\n        return np.array(X)\n    if not is_torch_data_type(X):\n        raise TypeError(\"Cannot convert this data type to a numpy array.\")\n    if X.is_cuda:\n        X = X.cpu()\n    if X.requires_grad:\n        X = X.detach()\n    return X.numpy()\n\n# def to_image(X):\n#     if isinstance(X,Image.Image):\n#         return X\n#     else:\n#         X=to_numpy(X)\n#         X=Image.fromarray(X)\n#         return X\n\nclass partial:\n    \"\"\"New function with partial application of the given arguments\n    and keywords.\n    \"\"\"\n    __slots__ = \"func\", \"args\", \"keywords\", \"__dict__\", \"__weakref__\"\n\n    def __new__(*args, **keywords):\n        if not args:\n            raise TypeError(\"descriptor '__new__' of partial needs an argument\")\n        if len(args) < 2:\n            raise TypeError(\"type 'partial' takes at least one argument\")\n        cls, func, *args = args\n        if not callable(func):\n            raise TypeError(\"the first argument must be callable\")\n        args = tuple(args)\n\n        if hasattr(func, \"func\"):\n            args = func.args + args\n            tmpkw = func.keywords.copy()\n            tmpkw.update(keywords)\n            keywords = tmpkw\n            del tmpkw\n            func = func.func\n\n        self = super(partial, cls).__new__(cls)\n\n        self.func = func\n        self.args = args\n        self.keywords = keywords\n        return self\n\n    def __call__(*args, **keywords):\n        if not args:\n            raise TypeError(\"descriptor '__call__' of partial needs an argument\")\n        self, *args = args\n        newkeywords = self.keywords.copy()\n        newkeywords.update(keywords)\n        return self.func(*self.args, *args, **newkeywords)\n    def change(self,**keywords):\n        self.keywords.update(keywords)\n        return self\n    @recursive_repr()\n    def __repr__(self):\n        qualname = type(self).__qualname__\n        args = [repr(self.func)]\n        args.extend(repr(x) for x in self.args)\n        args.extend(f\"{k}={v!r}\" for (k, v) in self.keywords.items())\n        if type(self).__module__ == \"functools\":\n            return f\"functools.{qualname}({', '.join(args)})\"\n        return f\"{qualname}({', '.join(args)})\"\n\n    def __reduce__(self):\n        return type(self), (self.func,), (self.func, self.args,\n               self.keywords or None, self.__dict__ or None)\n\n    def __setstate__(self, state):\n        if not isinstance(state, tuple):\n            raise TypeError(\"argument to __setstate__ must be a tuple\")\n        if len(state) != 4:\n            raise TypeError(f\"expected 4 items in state, got {len(state)}\")\n        func, args, kwds, namespace = state\n        if (not callable(func) or not isinstance(args, tuple) or\n           (kwds is not None and not isinstance(kwds, dict)) or\n           (namespace is not None and not isinstance(namespace, dict))):\n            raise TypeError(\"invalid partial state\")\n\n        args = tuple(args) # just in case it's a subclass\n        if kwds is None:\n            kwds = {}\n        elif type(kwds) is not dict: # XXX does it need to be *exactly* dict?\n            kwds = dict(kwds)\n        if namespace is None:\n            namespace = {}\n\n        self.__dict__ = namespace\n        self.func = func\n        self.args = args\n        self.keywords = kwds\n\nclass EMA:\n    \"\"\"\n    Implementation from https://fyubang.com/2019/06/01/ema/\n    \"\"\"\n\n    def __init__(self, model, decay):\n        self.model = model\n        self.decay = decay\n        self.shadow = {}\n        self.backup = {}\n\n    def load(self, ema_model):\n        for name, param in ema_model.named_parameters():\n            self.shadow[name] = param.data.clone()\n\n    def register(self):\n        for name, param in self.model.named_parameters():\n            if param.requires_grad:\n                self.shadow[name] = param.data.clone()\n\n    def update(self):\n        for name, param in self.model.named_parameters():\n            if param.requires_grad:\n                assert name in self.shadow\n                new_average = (1.0 - self.decay) * param.data + self.decay * self.shadow[name]\n                self.shadow[name] = new_average.clone()\n\n    def apply_shadow(self):\n        for name, param in self.model.named_parameters():\n            if param.requires_grad:\n                assert name in self.shadow\n                self.backup[name] = param.data\n                param.data = self.shadow[name]\n\n    def restore(self):\n        for name, param in self.model.named_parameters():\n            if param.requires_grad:\n                assert name in self.backup\n                param.data = self.backup[name]\n        self.backup = {}\n\nclass class_status:\n    def __init__(self,y):\n        self.y=y\n        try:\n            self.y_arr = to_numpy(self.y)\n        except (AttributeError, TypeError):\n            self.y_arr = self.y\n        if self.y_arr.ndim == 2:\n            self.y_arr = np.array([\" \".join(row.astype(\"str\")) for row in self.y_arr])\n    @property\n    def classes(self):\n        classes, y_indices = np.unique(self.y_arr, return_inverse=True)\n        return classes\n\n    @property\n    def y_indices(self):\n        classes, y_indices = np.unique(self.y_arr, return_inverse=True)\n        return y_indices\n\n    @property\n    def num_classes(self):\n        classes, y_indices = np.unique(self.y_arr, return_inverse=True)\n        num_class = classes.shape[0]\n        return num_class\n\n    @property\n    def class_counts(self):\n        classes, y_indices = np.unique(self.y_arr, return_inverse=True)\n        class_counts = np.bincount(y_indices)\n        return class_counts\n\n\ndef _l2_normalize(d):\n    d /= (torch.sqrt(torch.sum(d ** 2, dim=(1, 2, 3))).reshape((-1, 1, 1, 1)) + 1e-16)\n    return d\n\n\ndef one_hot(targets, nClass,device):\n    logits = torch.zeros(targets.size(0), nClass).to(device)\n    return logits.scatter_(1, targets.unsqueeze(1).long(), 1)\n\nclass Bn_Controller:\n    def __init__(self):\n        \"\"\"\n        freeze_bn and unfreeze_bn must appear in pairs\n        \"\"\"\n        self.backup = {}\n\n    def freeze_bn(self, model):\n        assert self.backup == {}\n        for name, m in model.named_modules():\n            if isinstance(m, nn.SyncBatchNorm) or isinstance(m, nn.BatchNorm2d):\n                self.backup[name + '.running_mean'] = m.running_mean.data.clone()\n                self.backup[name + '.running_var'] = m.running_var.data.clone()\n                self.backup[name + '.num_batches_tracked'] = m.num_batches_tracked.data.clone()\n\n    def unfreeze_bn(self, model):\n        for name, m in model.named_modules():\n            if isinstance(m, nn.SyncBatchNorm) or isinstance(m, nn.BatchNorm2d):\n                m.running_mean.data = self.backup[name + '.running_mean']\n                m.running_var.data = self.backup[name + '.running_var']\n                m.num_batches_tracked.data = self.backup[name + '.num_batches_tracked']\n        self.backup = {}\n"
  },
  {
    "path": "LICENSE",
    "content": "MIT License\n\nCopyright (c) 2022 Jialh2118\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
  },
  {
    "path": "README.md",
    "content": "<div align=center>\n<img width=\"750px\" src=\"./Imgs/Logo1.png\"> \n\n![](https://badgen.net/pypi/v/LAMDA-SSL)\n![](https://anaconda.org/ygzwqzd/lamda-ssl/badges/version.svg)\n![](https://badgen.net/github/last-commit/YGZWQZD/LAMDA-SSL)\n\n![](https://badgen.net/github/license/YGZWQZD/LAMDA-SSL)\n[![Downloads](https://pepy.tech/badge/lamda-ssl)](https://pepy.tech/project/lamda-ssl)\n![](https://anaconda.org/ygzwqzd/lamda-ssl/badges/platforms.svg)\n\n**[Documentation](https://ygzwqzd.github.io/LAMDA-SSL)** | **[Paper](https://arxiv.org/pdf/2208.04610.pdf)** |  **[Examples](https://github.com/ygzwqzd/LAMDA-SSL/tree/master/Examples)** | **[Slide](https://maipdf.com/doc/a15855342874@pdf)**\n\n</div>\n\n#  Introduction\n\nIn order to promote the research and application of semi-supervised learning (SSL) algorithms, we have developed LAMDA-SSL which is a comprehensive and easy-to-use toolkit for SSL in python. LAMDA-SSL has powerful functions, simple interfaces, and extensive documentation. It integrates statistical SSL algorithms and deep SSL algorithms into the same framework. At present, LAMDA-SSL contains 30 semi-supervised learning algorithms, including 12 algorithms based on statistical machine learning models and 18 algorithms based on deep learning models. LAMDA-SSL also contains 45 data processing methods used for 4 types of data: tabular, image, text, graph and 15 model evaluation criterias used for 3 types of task: classification, regression, and clustering. It is compatible with the popular machine learning toolkit scikit-learn and the popular deep learning toolkit Pytorch. It supports Pipeline mechanism and parameter search functions like scikit-learn and also supports GPU acceleration and distributed training functions like Pytorch. LAMDA-SSL includes multiple modules, such as data management, data transformation, model application, and model deployment, which facilitates the implementation of end-to-end SSL.\n\n<div align=center>\n<img width=\"1000px\" src=\"./Imgs/Overview.png\"> \n</div>\n\nAt present, LAMDA-SSL has implemented 30 SSL algorithms, including 12 statistical SSL algorithms and 18 deep SSL algorithms. \n\nFor statistical SSL, algorithms in LAMDA-SSL can be used for classification, regression and clustering. The algorithms used for classification task include generative method SSGMM; semi-supervised support vector machine methods TSVM and LapSVM; graph-based methods Label Propagation and Label Spreading; disagrement-based methods Co-Training and Tri-Training; ensemble methods SemiBoost and Assemble. The algorithm used for regression task is CoReg. The algorithms used for clustering task include Constrained K Means, Constrained Seed K Means.\n<div align=center>\n<img width=\"1000px\" src=\"./Imgs/Statistical.png\"> \n</div>\nFor deep SSL, algorithms in LAMDA-SSL can be used for classification and regression. The algorithms used for classification task include consistency methods Ladder Network, Π Model, Temporal Ensembling, Mean Teacher, VAT and UDA; Pseudo label-based methods Pseudo Label and S4L; hybrid methods ICT, MixMatch, ReMixMatch, FixMatch and FlexMatch; deep generative methods ImprovedGAN and SSVAE; deep graph-based methods SDNE and GCN. The algorithms for regression task include consistency method Π Model Reg, Mean Teacher Reg; hybrid method ICT Reg. These 3 deep SSL regression algorithms are our extensions of their prototypes used for classification.\n<div align=center>\n<img width=\"1000px\" src=\"./Imgs/Deep.png\"> \n</div>\n\n\n# Superiority\n\n- LAMDA-SSL contains 30 SSL algorithms.\n- LAMDA-SSL can handle 4 types of data and provides 45 functions for data processing and data augmentation.\n- LAMDA-SSL can handle 3 types of tasks and supports 16 metrics for model evaluation.\n- LAMDA-SSL supports 5 hyperparameter search methods including random search, grid search, Bayesian optimization, evolution strategy, and meta-learner.\n- LAMDA-SSL supports both statistical SSL algorithms and deep SSL algorithms and uses a unified implementation framework.\n- LAMDA-SSL is compatible with the popular machine learning toolkit scikit-learn and the popular deep learning toolkit Pytorch.\n- LAMDA-SSL has simple interfaces similar to scikit-learn so that it is easy to use.\n- LAMDA-SSL has powerful functions. It supports Pipeline mechanism and parameter search functions like scikit-learn and also supports GPU acceleration and distributed training functions like Pytorch.\n- LAMDA-SSL considers the needs of different user groups. It provides well tuned default parameters and modules for entry-level users. It also supports flexible module replacement and customization for professional users.\n- LAMDA-SSL has strong extensibility, which is convenient for users to customize new modules and algorithms.\n- LAMDA-SSL has been verified by a large number of experiments and has strong reliability.\n- LAMDA-SSL has comprehensive user documentation.\n\n\n# Dependencies\n\nLAMDA-SSL requires:\n\n> - python (>= 3.7)\n> - scikit-learn (>= 1.0.2)\n> - torch (>= 1.9.0)\n> - torchvision (>= 0.11.2)\n> - torchtext (>= 0.11.1)\n> - torch-geometric(>= 2.0.3)\n> - Pillow(>= 8.4.0)\n> - numpy(>= 1.19.2)\n> - scipy(>= 1.5.2)\n> - pandas(>= 1.3.4)\n> - matplotlib(>= 3.5.0)\n\nYou can create the environment directly by anaconda.\n\n```\nconda env create -f environment.yaml\n```\n\n# Installation\n\n## Install from pip\n\nYou can download LAMDA-SSL directly from pypi.\n```\npip install LAMDA-SSL\n```\n\n## Install from anaconda\n\nYou can also download LAMDA-SSL directly from anaconda.\n```\nconda install -c ygzwqzd LAMDA-SSL\n```\n\n\n## Install from the source\n\nIf you want to try the latest features that have not been released yet, you can install LAMDA-SSL from the source.\n```\ngit clone https://github.com/ygzwqzd/LAMDA-SSL.git\ncd LAMDA-SSL\npip install .\n```\n\n# Quick Start\n\nFor example, train a FixMatch classifier for CIFAR10.\n\nFirstly, import and initialize CIFAR10.\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\CIFAR10',\n                  labeled_size=4000,download=True)\nlabeled_X, labeled_y = dataset.labeled_X, dataset.labeled_y\nunlabeled_X = dataset.unlabeled_X\ntest_X, test_y = dataset.test_X, dataset.test_y\n```\n\nThen import and initialize FixMatch.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,mu=7,T=0.5,epoch=1,num_it_epoch=2**20,device='cuda:0')\n```\n\nNext, call the fit() method to complete the training process of the model.\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nFinally, call the predict() method to predict the labels of new samples.\n```python\npred_y=model.predict(X=test_X)\n```\n\n# Performance\n\nWe have evaluated the performance of LAMDA-SSL for semi-supervised classification task on table data using BreastCancer dataset. In this experiment, 30% of the instances are randomly sampled to form the testing dataset by the class distribution. Then 10% of the remaining instances are randomly sampled to form the labeled training dataset and the others are used to form the unlabeled training dataset by dropping their labels. For detailed parameter settings of each method, please refer to the 'Config' module of LAMDA-SSL.\n\n<div align=center>\n\n| Method | Accuracy(%) | F1 Score |\n| :-: | :-: | :-: |\n| SSGMM | 87.13 | 86.85 |\n| TSVM | 95.91 | 95.56 |\n| LapSVM | 96.49| 96.20 |\n| Label Propagation| 95.32| 94.86|\n| Label Spreading | 95.32 | 94.90 |\n| Co-Training| 94.74| 94.20 |\n| Tri-Training| 97.66| 97.47 |\n| Assemble | 94.15| 93.75 |\n| SemiBoost | 96.49 | 96.20 |\n\n</div>\n\nWe have evaluated the performance of LAMDA-SSL for semi-supervised regression task on table data using Boston dataset. In this experiment, 30% of the instances are randomly sampled to form the testing dataset by the class distribution. Then 10% of the remaining instances are randomly sampled to form the labeled training dataset and the others are used to form the unlabeled training dataset by dropping their labels. For detailed parameter settings of each method, please refer to the 'Config' module of LAMDA-SSL.\n\n<div align=center>\n\n| Method | Mean Absolute Error | Mean Squared Error |\n| :-: | :-: | :-: |\n|CoReg|\t4.66|\t59.52|\n|Π Model Reg|\t4.32|\t37.64|\n|ICT Reg\t|4.11|\t37.14|\n|Mean Teacher Reg\t|4.51|\t45.56|\n\n</div>\n\nWe have evaluated the performance of LAMDA-SSL for semi-supervised clustring task on table data using Wine dataset. In this experiment, 20% of the instances are randomly sampled to form the labeled dataset and the others are used to form the unlabeled dataset by dropping their labels. For detailed parameter settings of each method, please refer to the 'Config' module of LAMDA-SSL.\n\n<div align=center>\n\n| Method | Davies Bouldin Score | Fowlkes Mallows Score |\n| :-: | :-: | :-: |\n|Constrained k-means\t|1.76\t|0.75|\n|Constrained Seed k-means\t|1.38|\t0.93|\n\n</div>\n\nWe have evaluated the performance of LAMDA-SSL for semi-supervised clustring task on simple vision data using MNIST dataset. In this experiment, 10% of the instances in training dataset are randomly sampled to form the labeled dataset and the others are used to form the unlabeled dataset by dropping their labels. For detailed parameter settings of each method, please refer to the 'Config' module of LAMDA-SSL.\n\n<div align=center>\n\n| Method | Accuracy(%) | F1 Score |\n| :-: | :-: | :-: |\n|Ladder Network\t|97.37\t|97.36|\n|ImprovedGAN\t|98.81|\t98.81|\n|SSVAE|\t96.69|\t96.67|\n\n</div>\n\nWe have evaluated the performance of LAMDA-SSL for semi-supervised classification task on complex vision data using CIFAR10 dataset. In this experiment, 4000 instances in training dataset are randomly sampled to form the labeled training dataset and the others are used to form the unlabeled training dataset by dropping their labels. WideResNet is used as the backbone network. For detailed parameter settings of each method, please refer to the 'Config' module of LAMDA-SSL.\n\n<div align=center>\n\n| Method | Accuracy(%) | F1 Score |\n| :-: | :-: | :-: |\n|UDA\t|95.41|\t95.40|\n|Π Model\t|87.09|\t87.07|\n|Temporal Ensembling|\t89.30|\t89.31|\n|Mean Teacher|\t92.01\t|91.99|\n|VAT\t|88.22\t|88.19|\n|Pseudo Label|\t85.90|\t85.85|\n|S4L\t|89.59\t|89.54|\n|ICT\t|92.64\t|92.62|\n|MixMatch\t|93.43\t|93.43|\n|ReMixMatch\t|96.24\t|96.24|\n|FixMatch\t|95.34\t|95.33|\n|FlexMatch|\t95.39\t|95.40|\n\n\n</div>\n\nWe have evaluated the performance of LAMDA-SSL for semi-supervised classification task on graph data using Cora dataset. In this experiment, 20% of the instances are randomly sampled to form the labeled training dataset and the others are used to form the unlabeled training dataset by dropping their labels. For detailed parameter settings of each method, please refer to the 'Config' module of LAMDA-SSL.\n\n<div align=center>\n\n| Method | Accuracy(%) | F1 Score |\n| :-: | :-: | :-: |\n|SDNE|\t73.78|\t69.85|\n|GCN|\t82.04|\t80.52|\n|GAT|\t79.13|\t77.36|\n\n\n</div>\n\n# Citation\nPlease cite our paper if you find LAMDA-SSL useful in your work:\n```\n@article{jia2022lamdassl,\n      title={LAMDA-SSL: Semi-Supervised Learning in Python}, \n      author={Lin-Han Jia and Lan-Zhe Guo and Zhi Zhou and Yu-Feng Li},\n      journal={arXiv preprint arXiv:2208.04610},\n      year={2022}\n}\n```\n\n# Contribution\nFeel free to contribute in any way you like, we're always open to new ideas and approaches.\n- [Open a discussion](https://github.com/YGZWQZD/LAMDA-SSL/discussions/new) if you have any question.\n- Feel welcome to [open an issue](https://github.com/YGZWQZD/LAMDA-SSL/issues/new) if you've spotted a bug or a performance issue.\n- Fork our project and create a pull request after committing your modifications.\n- Learn more about how to customize modules of LAMDA-SSL from the [Usage](https://ygzwqzd.github.io/LAMDA-SSL/#/README?id=usage) section of the [documentation](https://ygzwqzd.github.io/LAMDA-SSL/#/).\n\n# Team\n LAMDA-SSL is developed by [LAMDA](https://www.lamda.nju.edu.cn/MainPage.ashx)@[NJU](https://www.nju.edu.cn/en/main.psp). Contributors are [Lin-Han Jia](https://github.com/YGZWQZD), [Lan-Zhe Guo](https://www.lamda.nju.edu.cn/guolz/), [Zhi Zhou](https://www.lamda.nju.edu.cn/zhouz/) and [Yu-Feng Li](https://www.lamda.nju.edu.cn/liyf/).\n\n# Contact\nIf you have any questions, please contact us: Lin-Han Jia[jialh@lamda.nju.edu.cn].\n"
  },
  {
    "path": "docs/.nojekyll",
    "content": ""
  },
  {
    "path": "docs/README.md",
    "content": "#  Introduction\n\nIn order to promote the research and applications of semi-supervised learning algorithms[1-3], we has developed LAMDA which is a convenient and practical semi-supervised learning toolkit. LAMDA-SSL has ample functions, simple interfaces and detailed documentation. It integrates statistical machine learning algorithms and deep learning algorithms into the same framework. It is compatible with the popular machine learning toolkit sklearn[34] and the popular deep learning toolkit pytorch. It supports Pipeline mechanism and parameter search functions of sklearn and also supports GPU acceleration and distributed training functions of pytorch. At present, LAMDA-SSL contains 30 semi-supervised learning algorithms, including 12 statistical semi-supervised learning algorithms and 18 deep semi-supervised learning algorithms. LAMDA-SSL also contains plentiful data processing and augmentation methods used for 4 types of data: tabular, image, text, graph and plentiful model evaluation metrics used for 3 types of task: classification, regression and clustering. LAMDA-SSL includes multiple modules such as data management, data transformation, model application and model deployment, which facilitates the end-to-end semi-supervised learning process.\n\n##  Background\n\nIn recent years, the research on machine learning algorithms has achieved fruitful results, but there are still many difficulties in real-world scenarios because it is often impossible to obtain sufficient and high quality data resources. The scarcity of labels is particularly serious. Especially in the fields of automatic operation, finance, medical care etc, the acquisition of labels is limited by privacy, cost and risk, which seriously degrades the performance of machine learning algorithms that rely on a large amount of labeled data.\n\n<div align=center>\n<img width=1000px src=\"./Imgs/Scarcity_of_labels.png\" >\n<br>\nFigure 1: Labeled Data is Often Lacking in Real-World Machine Learning Applications\n</div>\n\nSupervised learning and unsupervised learning are two classical machine learning paradigms. The success of supervised learning relies on a large amount of high-quality labeled data. When labeled data is limited, the performance of supervised learning models often falls short of expectations. This makes it naturally incompatible with application scenarios where labels are difficult to obtain. In these scenarios, labeling large amounts of data artificially will not only cost a lot of manpower, but also take a long time. Unsupervised learning completely discards the information from the labels so it cannot establish the connection between the feature space and the target space. It is difficult to be applied to tasks such as classification and regression. In order to deal with the scarcity of labels in real application scenarios, semi-supervised learning which uses a small amount of labeled data and a large amount of unlabeled data for learning emerges and breaks the existing learning paradigms by establishing the connection between the feature space and the target space through prior knowledge and assumptions.\n\n<div align=center>\n<img width=1000px src=\"./Imgs/MLParadigm.png\" >\n<br>\nFigure 2: Classical Machine Learning Paradigms and Semi-Supervised Learning Paradigm\n</div>\n\nSemi-supervised learning is highly suitable for real-world application scenarios and the learning mode of human beings so it has a wide range of application prospects. However, compared with classical machine learning paradigms, the development of the semi-supervised learning currently has many difficulties such as more complex learning process, more difficult algorithm design and implementation, and relative lack of reference documents, which seriously limits the popularity of this field in practical applications. Therefore, designing and implementing a convenient toolkit for semi-supervised learning can promote wider implementations of semi-supervised learning algorithms in practical scenarios. It can help semi-supervised learning go from laboratory to industry.\n\n## Purpose\n\nThe complexity of semi-supervised learning problems has created serious knowledge and skill barriers for toolkit developers, resulting in a lack of convenient semi-supervised learning toolkits. In order to meet the needs of users for semi-supervised learning technology in practical applications, a mature and easy-to-use semi-supervised learning toolkit should have the following characteristics:\n1) It should have advanced design pattern considering user needs from the perspectives of both data and model to make the interfaces as simple as possible and the functions as powerful as possible;\n2) The scope of application should be wide enough, such as supporting multiple common data types such as tables, images, texts and graphs and supporting multiple common task types such as classification, regression, and clustering;\n4) It should be easy to use and expandable. Taking into account the needs of different user groups, it should provide convenient usage methods, default parameters and interfaces for users with low proficiency and support flexible module replacement and customization for users with high proficiency;\n5) Its effectiveness should be verified through a large number of experiments and the performances of different algorithms in various scenarios should be compared;\n6) There should be rich and convenient documents for users to reference.\n\nIn order to solve the above problems, we developed LAMDA-SSL, a semi-supervised learning toolkit with advanced design pattern, wide application scenarios, rich algorithms, convenient functional interfaces, excellent model effect and detailed documentation. At present, this toolkit covers 30 semi-supervised learning algorithms, including 12 algorithms based on statistical machine learning models and 18 algorithms based on deep neural network models. It includes a variety of data transformation techniques, which can be used to process 4 data types of data: table, image, text and data. It includes a variety of model evaluation methods, which can be used for classification, regression, and clustering tasks. It includes multiple modules such as data management, data transformation, model application, and model deployment, which is easy to complete end-to-end Semi-supervised learning process. It is compatible with popular machine learning toolkit sklearn and deep learning toolkit pytorch, supporting sklearn's Pipeline and parameter search functions and pytorch's GPU acceleration and distributed training functions. It provides users with convenient toolkit usage documents, detailed API documents and rich introduction documents for semi-supervised learning algorithms. It provides good default parameters for non-professional users, and provides convenient and low-coupling module replacement and customization interfaces for professional users.\n\nLAMDA-SSL is currently a semi-supervised learning toolkit with the largest number of algorithms, the most supported data types, the most supported tasks, the most abundant functions, the most convenient interface, and the most detailed documentation. It is also the first semi-supervised learning toolkit which integrates statistical machine learning algorithms and deep learning algorithms into a same framework and is compatible with both sklearn and pytorch.\n\n## Design Mode\n\nCompared with other semi-supervised learning tools, LAMDA-SSL is more advanced in design mode, and has the advantages of low coupling, high flexibility, strong scalability and simple interfaces. Based on these advantages, LAMDA-SSL can help users in the industry quickly get started with semi-supervised learning technology and enjoy the performance improvement brought by semi-supervised learning in business with almost zero cost.\n\nLAMDA-SSL is divided into two modules: data module and model module in design (as shown in Figure 3). The data module includes data management and data transformation, which can be used for four data types: table, image, text and graph. The model module includes model application and model deployment for three task types: classification, regression, and clustering.\n\n<div align=center>\n\n<img width=1000px src=\"./Imgs/Overview.png\" >\n\n<br>\n\nFigure 3: The structure of LAMDA-SSL\n\n</div>\n\n\n### Data Module\n\nThe design idea of the data module of LAMDA-SSL is shown in Figure 4.\n\n<div align=center>\n\n<img width=1000px src=\"./Imgs/DataModule.png\" >\n\n<br>\nFigure 4: Data Module of LAMDA-SSL\n\n</div>\n\nDataset: In LAMDA-SSL, all datasets inherit from pytorch's Dataset class. There are two methods to use a dataset, one of which is using the whole dataset directly and the other one is loading the dataset batch by batch. A whole semi-supervised dataset can be managed by a SemiDataset class. The SemiDataset class can manage three sub-datasets: TrainDataset, ValidDataset, and TestDataset at the same time. At the bottom, the datasets are divided into LabeledDataset and UnlabeledDataset. The training dataset often contains both labeled data and unlabeled data, so TrainDataset manages both LabeledDataset and UnlabeledDataset.\n\nData Transformation: In sklearn, data transformers inherit both BaseEstimator and TransformerMixin class. The former is the base estimator class of sklearn and the latter is the data transformer component of sklearn. Data transformers generally have two methods: fit() and transform(). The fit() method learns data processing methods based on existing data and the transform() method is used to transform new data. A large number of data transformers can omit fit() method and transform the data directly. The data transformers can also continuously complete the fit() and transform() processes by the fit_transform() interface. In sklearn, data transformers support Pipeline mechanism, which enables pipelined encapsulation and management for multiple processing steps. The data processing and data augmentation methods in LAMDA-SSL have the same mechanism with data transformers in sklearn by inheriting the Transformer class. In deep semi-supervised learning, because the amount of data is huge and data augmentation may be required according to algorithm requirements, usually not all instances are processed before model training, but are processed during the data loading process. So it is necessary to set the data processing method for the dataset class in advance and automatically process the data loaded by the data loader during the training process. In TorchVision which is an expansion toolkit of pytorch in computer vision field, there are three types of data processing: transform, target_transform and transforms, which are used to transform X, transform y, and transform both X and y at the same time respectively. In semi-supervised learning, these three methods are not universal in all cases, so LAMDA-SSL adds unlabeled_transform, valid_transform and test_transform for unlabeled samples, validation samples and test samples. In addition, the pre_transform process is added for the situation where data augmentations are required in the data transformation process. The pre_transform process and the transform process represent the processing of data before and after data augmentation respectively. For example, for CIFAR10 dataset, the original data type is numpy.ndarray. In the case when data augmentations are needed, it is necessary to convert the samples from numpy.ndarray to image before data augmentations and convert the samples from image to torch.Tensor after data augmentations. The conversion process from numpy.ndarray to image corresponds to the pre_transform process and the conversion process from image to torch.Tensor corresponds to the transform process. User-specified data augmentation methods can be flexibly added according to algorithm requirements between the pre_transform process and the transform process.\n\nDataloader: In deep semi-supervised learning, the amount of data is usually large so the data needs to be loaded in batches by the sampler. In each iteration, a batch of instances is sampled and indexed by the __getitem__() method. Then the indexed instances are combined into torch.Tensor. LAMDA-SSL designs LabeledDataloader and UnlabeledDataloader for LabeledDataset and UnlabeledDataset respectively and uses a TrainDataloader class to manage the training process of the two dataloaders for semi-supervised learning. In addition to including two dataloaders at the same time, TrainDataloader also plays a role in adjusting the relationship between them, such as adjusting the ratio of of the number of samples and the batch size between unlabeled instances and labeled instances.\n\nData-specific Mixin: LAMDA-SSL can handle four common data types in practical applications: table, image, text, and graph. It designs four components corresponding to the data types: TabularMixin, VisionMixin, TextMixin, and GraphMixin. For a dataset, you can inherit the component corresponding to its data type to obtain the default data processing function in the component. For example, CIFAR10 inherits two modules: SemiDataset and VisionMixin and thus has the default image data processing function. For custom datasets, users can set the data source of the dataset by overriding the init_dataset() method in SemiDataset and set the default data processing flow by overriding the init_default_transform() method of the Mixin module.\n\n### Model Module\n\nThe design idea of the model module of LAMDA-SSL is shown in Figure 5.\n\n<div align=center>\n\n<img width=1000px src=\"./Imgs/ModelModule.png\" >\n\n<br>\nFigure 5: Model Module of LAMDA-SSL\n\n</div>\n\nEstimator: LAMDA-SSL refers to the implementation of sklearn and all learners use the similar interfaces to sklearn. In sklearn, learners all inherit the parent class BaseEstimator and usually have two methods: fit() and predict(). The fit() method uses existing data to train a model, which corresponds to the training process in machine learning. The predict() method uses the model after fit() to predict the labels of new samples which corresponds to the prediction process in machine learning. The learner in LAMDA-SSL indirectly inherits BaseEstimator in sklearn by inheriting SemiEstimator. Since the input of the fit() method in sklearn only includes samples and labels but in semi-supervised learning, the model needs to use labeled samples, labels and unlabeled samples at the same time during the training process. Therefore, BaseEstimator's fit() method interface is not convenient for direct use in semi-supervised learning algorithms. Although sklearn also implements two types of semi-supervised learning algorithms by combining the labeled samples and unlabeled samples and mark the labels corresponding to the unlabeled sample as -1. This processing method can adapt to the interface of BaseEstimator but it also has limitations, especially in some binary classification scenarios, -1 is often used to indicate the negative class of the labeled samples. So it is necessary to re-establish a new class SemiEstimator based on BaseEstimator for semi-supervised learning. The fit() method of SemiEstimator includes three parts of input: labeled samples, labels and unlabeled samples, which better fits the application scenario of semi-supervised learning avoiding requirements for users to combine data and conflicts between negative samples and unlabeled samples. Semi-supervised learning is generally divided into inductive learning and transductive learning. The difference is whether the data to be predicted is directly used as the unlabeled data in the training process. Inductive learning uses labeled instances and known unlabeled samples to train a learner to predict the labels of unknown unlabeled data; while transductive learning uses labeled instances and known unlabeled samples to directly predict the labels of known unlabeled samples. Usually, a transductive methods can also be extended to an inductive method by adding some new mechanisms on the basis of the original algorithm. The two classes InductiveEstimator and TransductiveEstimator used in LAMDA-SSL correspond to two semi-supervised learning paradigms respectively and both inherit the SemiEstimator class. The predict() method of InductiveEstimator needs to input new samples to be predicted. While the predict() method of TransductiveEstimator determines whether to use transductive prediction by a BOOL type parameter 'Transductive'. If it is True, no new samples need to be input and the learner output the transductive prediction result directly, otherwise the expansion mechanism will be triggered to predict for newly input samples.\n\n```python\nfrom sklearn.base import BaseEstimator\nfrom abc import ABC,abstractmethod\nclass SemiEstimator(ABC,BaseEstimator):\n    @abstractmethod\n    def fit(self,X,y,unlabeled_X):\n        raise NotImplementedError(\n            \"The fit() method of SemiEstimator must be implemented.\"\n        )\n```\n\nTask-specific Mixin: In sklearn, in order to enable learners to have corresponding functions for different tasks, sklearn develops components corresponding to tasks for learners. The learners in sklearn often inherit BaseEstimator and corresponding components at the same time, so that in addition to the basic training and prediction functions, the learner can also have the function of completing the task corresponding to the component. The commonly used components include ClassifierMixin for classification tasks, RegressorMixin for regression tasks, and ClusterMixin for clustering tasks which are also used in LAMDA-SSL. Taking the TSVM algorithm as an example, it inherits TransductiveEstimator and ClassifierMixin and can be used for transductive semi-supervised classification tasks.\n\nDeep SSL Model Mixin: Different from the framework of sklearn which is commonly used in statistical machine learning, the framework of pytorch is often used in deep learning and its interfaces are quite different from that of sklearn, making it difficult to integrate deep learning algorithms and statistical machine learning algorithms into the same framework. In addition, there are large dependency and hign coupling among the components of pytorch. In the data module, the Sampler module depends on the Dataset module and the Dataloader module depends on both the Sampler module and the Dataset module. In the model module , the Scheduler module depends on the Optimizer module, the Optimizer module and the Parallel module depend on the Network module. Compared with sklearn, the logic and interfaces of Pytorch are more complex, so the requirements for users themselves are higher. In order to solve the problem that statistical machine learning methods and deep learning methods are difficult to be integrated into a same framework, LAMDA-SSL uses the DeepModelMixin component to enable the deep semi-supervised learning model developed based on pytorch to have the same interface and usage as the statistical semi-supervised learning method. DeepModelMixin decouples each module of pytorch, which is convenient for users to independently replace or customize the dataloader, network, optimizer and other modules in deep learning without considering the impact of replacement on other modules. It enables users to call deep semi-supervised learning algorithms as easily as calling statistical semi-supervised learning algorithms. In addition, DeepModelMixin not only supports users to replace components in deep learning, but also deconstructs the training and prediction process of deep semi-supervised learning models into multiple modules such as data processing, forward propagation, computational loss, model optimization etc. It is convenient for users to adjust existing deep semi-supervised learning algorithms or customize new deep semi-supervised learning algorithms avoiding a lot of repetitive work. The structure of DeepModelMixin is shown in Figure 6.\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/DeepModelMixin.png\" > \n\n<br>\nFigure 6: The structure of DeepModolMixin\n</div>\n\nTask-specific Evaluation: LAMDA-SSL provides a variety of evaluation indicators for classification, regression, and clustering tasks for model evaluation and monitoring. The model evaluation of LAMDA-SSL has two forms. The first is to call the evaluation module after the prediction result is obtained. The second is to directly use the evaluation metrics as the attribute of the learner when the learner is initialized, so that the model can be evaluated after the prediction is completed and for deep semi-supervised learning algorithms, real-time evaluation can be performed during the model training process. The evaluation metrics for three different tasks inherit three base classes: ClassifierEvaluation, RegressorEvaluation and ClusterEvaluation.\n\n\n## Application Scenarios\n\nLAMDA-SSL has a wide range of application scenarios. It can support four types of data: tables, images, texts and graphs (as shown in Figure 7) and three types of task: classification, regression and clustering (as shown in Figure 8). LAMDA-SSL can leverage the value of semi-supervised algorithms in various real-world businesses.\n\n### Data Types\n\n<div align=center>\n<img width=\"600px\"  src=\"./Imgs/DataType.png\" > \n<br>\nFigure 7: Data scenarios of LAMDA-SSL\n</div>\n\nTable is the most basic form of data. There is no spatial and temporal connection between features and samples for this type of data. A large part of statistical machine learning algorithms are designed for table data. It is widely used in applications such as stock analysis and network anomaly detection. For table data, the preprocessing module in sklearn has already provided rich enough processing methods, such as 'StandardScaler', 'MinMaxScaler', 'MaxAbsScaler' etc. LAMDA-SSL supplements it on the basis. The TabularMixin module provides the default processing method for table data, using 'StandardScaler' as the default pre-transformation method. After pre-transformation, data augmentation is performed according to requirements. If it is applied to deep learning, the data will be converted into torch.Tensor form. In order to perform data augmentation on table data, LAMDA-SSL implements the augmentation method 'Noise' which apply a noise disturbance that obeys normal distribution is to the standardized data and the disturbance amplitude is controlled by the standard deviation of the normal distribution.\n\nImage data is one of the most commonly used data types in the field of deep learning. It is used in the learning process in the form of tensors and there are spatial relationships among its features. This data type is widely used in medical imaging, automatic driving, security recognition and other fields. For image data, TorchVision has provided processing some methods for image data, such as cropping, rotation, sharpening, etc. LAMDA-SSL supplements it on the basis. The VisionMixin module provides a default processing method for image data. During the pre-transformation process, the samples stored in other forms are converted into images. After the pre-transformation, the samples are augmented according to requirements. Finally the images are converted into the types can be processed by models. For data augmentation of image data, LAMDA-SSL provides a variety of weak augmentation methods such as 'RandomCrop' and 'RandomHorizontalFlip' and strong augmentation methods such as 'RandAugment' and 'Cutout'.\n\nText data is another data type with a wide range of application scenarios in the field of deep learning, which drives the rapid development of natural language processing. Texts are often converted into vectors through various embedding methods and there are temporal relationships among its features. This data type has a wide range of applications in machine translation, sentiment analysis and information retrieval. For text data, TorchText has provided some text data processing methods, such as tokenization, word embedding, etc.  LAMDA-SSL supplements it on the basis. The TextMixin module provides the default processing method for text data. Firstly, the text is tokenized in the preprocessing stage. Then the data is augmented according to the requirements. Finally, the text length is adjusted, and tokens are converted into indexes through a dictionary to constitutes the Tensor as the input of the model. For data augmentation of text data, LAMDA-SSL provides a variety of weak augmentation methods such as 'Random Swap' and 'Random Delete' and strong augmentation methods such as 'TF-IDF Replacement' whose basic idea is replacing unimportant words whose TF-IDF value is low will not have too much influence on text semantics.\n\nGraph data has been the focus of deep learning in recent years. Unlike other data types which only have spatial and temporal relationships between features, graph data needs to consider the spatial relationships between samples, that is the structural information of the graph. This data type has important application prospects in social networks, drug discovery, recommender systems etc.\nFor graph data, LAMDA-SSL uses the data form in torch_geometric as the standard which encapsulates the graph structure information, node features information, node labels information in the Dataset class and divides nodes into training set, validation set and test set by masks. LAMDA-SSL further divides the training set on this basis by parameters 'labeled_mask' and 'unlabeled_mask'. The GraphMixin module takes the standardization of node features in the graph as the default data transformation method and provides transformation methods such as 'Graph Diffusion Convolution'[37], 'SVD Feature Reduction', 'GCNNorm', etc. Data augmentations for graph are performed by removing nodes or edges in the graph.\n\n<style>\n.center \n{\n  width: auto;\n  display: table;\n  margin-left: auto;\n  margin-right: auto;\n}\n</style>\n\n<div align=center class=\"center\">\n\nTable 1: Data processing and data augmentation in LAMDA-SSL\n\n|Types of data|Data Processing|Data Augmentation|\n|:-:|:-:|:-:|\n|Tabular|StandardScaler<br>MinMaxScaler<br>MaxAbsScaler|Noise|\n|Vision|Resize<br>Normlization|RandomCrop<br>RandomHorizontalFlip<br>AutoContrast<br>Brightness<br>Color<br>Contrast<br>Rotate<br>Sharpness<br>Equalize<br>Solarize<br>Posterize<br>Invert<br>ShearX<br>ShearY<br>TranslateX<br>TranslateY<br>RandAugment<br>Cutout<br>CutoutAbs<br>Mixup|\n|Text|Tokenizer<br>Truncate<br>PadSquence<br>AdjustLength<br>Vocab<br>Vectors<br>Glove<br>FastText<br>CharNGram|RandomDeletion<br>RandomSwap<br>TFIDFReplacement|\n|Graph|GCNNorm<br> GDC<br> SVDFeatureReduction<br> NormalizeFeatures|DropNodes<br>DropEdges|\n</div>\n\n### Task Types\n\n<div align=center>\n<img width=\"600px\"  src=\"./Imgs/TaskType.png\" > \n<br>\nFigure 8: Task scenarios of LAMDA-SSL\n</div>\n\nThe classification task is one of the most basic tasks in the field of machine learning. The prediction result of the model is a discrete value, which is often used in scenarios such as behavior prediction, target recognition and content filtering. For classification tasks, LAMDA-SSL provides a large number of algorithms as well as various evaluation metrics such as 'Accuracy', 'Recall', 'Precision', 'F1 Score' which can utilize ground-truth labels, model-predicted hard labels and soft labels to evaluate the model's performance.\n\nThe regression task is another basic task in the field of machine learning. The prediction result of the model is a continuous value, which is often used in scenarios such as price forecasting, sales forecasting and credit scoring. At present, the related research in the field of semi-supervised regression is immature and there are few algorithms available, especially deep semi supervised learning algorithms. In addition to the semi-supervised regression algorithm CoReg, LAMDA-SSL also extends some deep semi-supervised learning algorithms for classification, making them suitable for regression tasks. LAMDA-SSL also provides a variety of evaluation metrics such as 'Mean Absolute Error', 'Mean Squared Error' and 'Mean Square Log Error'.\n\nThe clustering task is the most classical application of unsupervised learning. It cannot use real labels to establish the connection between the feature space and the target space. It is widely used in scenarios where real labels do not exist, such as anomaly detection, customers management and value combination. For clustering tasks, the algorithms in LAMDA-SSL all introduce some supervised information based on the original unsupervised clustering algorithms to guide the clustering process, so that the clustering results are more consistent with the real labels. LAMDA-SSL provides two types of clustering evaluation metrics. The first type is external metrics such as ‘Fowlkes Mallows Score’[39] and ‘Rand Score’[40], which are used when there are reliable reference results. The models' performance are evaluated by comparing the difference between the clustering results and the reference results. They are more suitable for the situation where the samples itself have labels. The second type is the internal metrics such as 'Davies Bouldin Score'[38] and 'Silhouette Score' which do not depend on the reference result and evaluate the models' performance only according to the features of the samples and the clustering results.\n\n<div align=center class=\"center\">\n\nTable 2: Evaluation Metrics in LAMDA-SSL\n\n|Type of Task|Evaluation Metric|\n|:-:|:-:|\n|Classification|Accuracy<br>Top k Accuracy<br>Recall<br>Precision<br>F1 Score<br>AUC<br>Confusion Matrix|\n|Regression|Mean Absolute Error<br>Median Absolute Error<br>Mean Squared Error<br>Mean Squared Log Error|\n|Clustring|Davies Bouldin Score<br>Fowlkes Mallows Score<br>Jaccard Score<br>Rand Score<br>Silhouette Score|\n\n</div>\n\n## Algorithms\n\nLAMDA-SSL implements up to 30 semi-supervised learning algorithms, including 12 statistical machine learning algorithms and 18 deep learning algorithms, providing users with a variety of choices.\n\n### Statistical Learning Algorithms\n\nLAMDA-SSL contains 12 semi-supervised learning algorithms based on statistical machine learning models (as shown in Figure 9), among which the algorithms used for classification tasks include generative method SSGMM, semi-supervised support vector machine methods TSVM, LapSVM, graph-based methods Label Propagation, Label Spreading, disagreement-based methods Co-Training, Tri-Training, ensemble methods SemiBoost, Assemble; the algorithms used for regression tasks include CoReg; the algorithms used for clustering tasks include Constrained K Means, Constrained Seed K Means.\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/Statistical.png\" > \n\n<br>\n\nFigure 9: Statistical Semi-Supervised Learning Algorithms in LAMDA-SSL\n</div>\n\nGenerative semi-supervised learning methods are based on generative models, which assume that the data is generated from a latent distribution, while semi-supervised generative methods treat the labels of unlabeled samples as latent variables and use expectation-maximization(EM) algorithm to solve. SSGMM stands for Semi-Supervised Gaussian Mixture Model. It is assumed that the data is generated by a Gaussian mixture model, which means the marginal distribution of sample features can be expressed as the result of mixing several Gaussian distributions together and each Gaussian distribution is given a weight. For unlabeled samples, each Gaussian mixture component can be corresponding to a category and the samples can be classified into the category corresponding to the Gaussian mixture component with the highest weight.\n\nSemi-supervised support vector machine is a generalization of the support vector machine algorithm in the field of semi-supervised learning. The semi-supervised support vector machine introduces a low-density assumption, that is the learned hyperplane should not only make the classification interval as large as possible, but also pass through the low-density area of ​​the distribution of all samples as much as possible. TSVM is the most basic semi-supervised support vector machine method, which completes the learning by continuously swaping pseudo-labels of unlabeled sample pairs which don't belong to the same class currently and may be misclassified in each iteration. LapSVM introduces manifold regularization, constructs a graph model and guides the model to predict the results of adjacent samples in the graph as consistent as possible through the Laplace regular term, so that the unlabeled samples can participate in the learning process by using the distribution of samples on the manifold.\n\nThe graph-based semi-supervised learning methods represent the dataset as a graph structure model which have both labeled nodes and unlabeled nodes. Therefore, graph-based semi-supervised learning can be regarded as the process of label propagation in the graph. Label Propagation is the most basic method. It takes the Laplace regular term as the optimization goal, and solves the labels of the unlabeled data to make the optimization goal minimum. Based on Label Propagation, Label Spreading cancels the limitation that the model's prediction results for labeled samples must be equal to their true labels during the propagation process, but penalizes erroneous results.\n\nDisagreement-based semi-supervised learning methods depend on multiple learners with significant divergence and use the disagreement between learners to utilize unlabeled data. Such methods are less affected by model assumptions, non-convexity of loss function and data scale problems. These methods are simple and effective and have solid theoretical foundation relatively. The Co-Training algorithm uses two basic learners to generate divergence through different data views and uses the compatibility and complementarity of multiple views to promote each other's training. Tri-training uses three basic learners to generate pseudo-labels through \"minority obeys majority\", and ensembles the learners to produce the final prediction results.\n\nEnsemble learning methods combine multiple weak learners to improve the reliability of the model. In the field of semi-supervised learning, due to the addition of unlabeled data, the instability of a single learner is further exacerbated, so there is a stronger reliance on effective ensemble learning methods. Assemble stands for adaptive semi-supervised ensemble. which is an extension of the adaptive boosting(AdaBoost). In each round of iterations, pseudo-labels are assigned to unlabeled samples by the current ensemble learner and the sampling weights are adjusted adaptively according to the difference between the model prediction results and the current pseudo-labels obtained by the ensemble learner. SemiBoost further considers the relationships among samples based on the graph semi-supervised learning methods. It points out that larger sampling weights should be set for the samples with high similarity but large inconsistency in the prediction results compared with other samples.\n\nCompared with classification algorithms, semi-supervised regression algorithms are more difficult to make reasonable assumptions. Research on semi-supervised regression is more difficult than semi-supervised classification. CoReg introduces the Co-Training algorithm into the regression task. Co-Training can't complete the traning process of regression tasks since it is difficult to evaluate the confidence of the learner to each sample, CoReg takes the difference in mean square error before and after adding an unlabeled sample as the evaluation criterion for confidence of the learner to this sample.\n\nThe semi-supervised clustering algorithms introduce supervised information to assist the process of unsupervised clustering. The supervised information is not necessarily labeled data, but may also be other knowledge related to real labels. Constrained k-means introduces constraints called must-link and connot-link as supervision information based on the k-means clustering algorithm. The must-link constraints restrict that some samples must belong to the same cluster. The must-link constraints restrict that some samples must belong to different clusters. Constrained Seed k-means is different from Constrained k-means which uses must-link and connot-link constraints as supervision information, but directly uses a small amount of labels as supervision information.\n\n### Deep Learning Algorithms\n\nLAMDA-SSL contains 18 deep model-based semi-supervised learning algorithms (as shown in Figure 10): the algorithms used for classification tasks include the consistency regularization method Ladder Network, Π Model, Temporal Ensembling, Mean Teacher, VAT, UDA, Pseudo label-based methods Pseudo Label, S4L, hybrid methods ICT, MixMatch, ReMixMatch, FixMatch, FlexMatch, generative methods ImprovedGAN, SSVAE, deep graph based methods SDNE, GCN and GAT; the algorithms for regression tasks include consistency regularization method Π Model Reg, Mean Teacher Reg and hybrid method ICT Reg.\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/Deep.png\" > \n\n<br>\n\nFigure 10: Deep Semi-Supervised Learning Algorithms in LAMDA-SSL\n</div>\n\nConsistency methods are based on the consistency assumption which assumps that the prediction result should remain unchanged as much as possible when a certain range of disturbance is added to the samples. In these methods, a large amount of unlabeled data can be used to improve the robustness of the model. The Ladder network adopts the symmetric autoencoder structure and takes the inconsistency of each hidden layer between the decoding results after the data is encoded with noise and the encoding results without noise as the unsupervised loss. UDA stands for unsupervised data augmentation. After performing data augmentations on the unlabeled samples, the prediction results for the samples before and after the augmentation are compared, and the mean square error loss is used to calculate the consistency regular term as the unsupervised loss. Π Model performs random data augmentation twice on the same samples, and uses the results of the two augmentations as the inputs of the neural network model respectively. The inconsistency of the predicted results are used as the unsupervised loss. Temporal Ensembling has made some improvements to the Π Model, changing one of the two augmented prediction results to an exponential moving average(EMA) for historical pseudo-labels which alleviates the model's forgetting of historical information and reduces computing power consumption. Mean Teacher uses the idea of ​​knowledge distillation and the teacher model is not a complex model, but a model based on the student model using the exponential moving average parameters. Unlike other methods adds random noise to the samples, VAT adds adversarial noise, so that the worst performance of the model will not be too bad when the data is affected by noise under certain constraints.\n\nThe pseudo-labels based methods make the unlabeled samples affect the learning process by assigning pseudo-labels to the unlabeled data. Since the confidences of the model for different samples are different, methods based on pseudo-labels usually take samples with higher confidence to participate in the training process. Pseudo Label sets a confidence threshold. In each iteration, the part of samples with confidence higher than the threshold are selected to calculate the cross-entropy loss as the unsupervised loss. S4L uses self-supervised technology to construct self-supervised tasks. The target task and the self-supervised task share the same representation layer. So that the model can use unlabeled data to learn better hidden layers using self-supervised labels as pseudo-labels.\n\nThe hybrid methods are not limited to using only one type of technology, but combine consistency and pseudo-label technology together. Hybrid approaches tend to be more general because of the use of multiple techniques simultaneously. ICT stands for interpolation consistency training. The data and prediction results are linearly interpolated by Mixup and the inconsistency between the model's prediction result for the interpolated sample and the interpolation of model's prediction results for the original samples is used as an unsupervised loss. MixMatch also uses Mixup, but unlike ICT which only Interpolates unlabeled samples and their pseudo-labels, MixMatch mixes labeled data and unlabeled data together and interpolates the mixed samples and their labels or pseudo-labels. ReMixMatch is an improved version of MixMatch, which introduces two techniques: distribution alignment and augmented anchoring. The purpose of distribution alignment is to make the pseudo-labels predicted by the model for unlabeled samples have the same probability distribution as the labels of labeled samples. The purpose of augmented anchoring is to adapt the model to stronger data augmentation, so that pseudo-labels do not change with increasing augmentation strength. FixMatch performs strong data augmentation and weak data augmentation on the samples respectively and takes the inconsistency of the model's prediction results as the unsupervised loss. FlexMatch is an improvement to FixMatch. It focuses on solving the unfairness between categories in semi-supervised learning. Different confidence thresholds are used to select samples for different classes which alleviates the class imbalance caused by different learning difficulties.\n\nDeep generative methods use real data to model a data distribution, and this distribution can be used to generate new data. Unlike classical generative methods, deep generative methods generate data based on deep neural networks. Most of them are variations of Generative Adversarial Network(GAN) and Variational AutoEncoder(VAE). The discriminator of ImprovedGAN is different from GAN because it need not only discriminate whether the sample is a real sample or a generated sample, but also calssify the real samples. SSVAE divides the encoder of VAE into two parts. The first part encodes the original samples to obtain the probability distribution of their labels, and the second part uses the original samples and pseudo-labels as input to obtain the probability distribution of latent variables.\n\nDeep Graph-based methods are mainly used when the original data is graph data. Instances in the graph are not independent, but are connected by edges. In reality, learning tasks on graph data are often semi-supervised, that is, there are both labeled and unlabeled nodes in the graph. SDNE is a semi-supervised graph deep learning method that can learn the embedding vector of nodes in the graph when there are no features for the nodes. The adjacency vectors are used as the feature vectors input to learn the representations of the nodes by the encoder. GCN is more suitable for the situation that the nodes itself have features. It can use the features information of the nodes and the graph structure information to learn at the same time. It can aggregate the information of the adjacent nodes by graph convolution to update the node representation. GAT is also applicable to the case where the node itself has features. Unlike the graph convolution operation of GCN, GAT introduces the  attention mechanism. In each iteration, the attention weight of each node is calculated according to the representations of itself and its neighboring nodes and its representation is updated with the weight.\n\n# Usage Tutorial\n\n## Dataset Initialization\n\nTaking the CIFAR10 dataset as an example, firstly import the CIFAR10 class.\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n```\n\nInstantiate a CIFAR10 class. The parameter 'root' indicates the storage address of the dataset, the parameter 'labeled_size' indicates the number or proportion of labeled samples and the parameter 'stratified' indicates whether to divide the dataset according to the class distribution. The parameter 'shuffle' indicates whether the dataset needs to be shuffled and the parameter 'download' indicates whether the dataset needs to be downloaded.\n\n```python\ndataset=CIFAR10(root='..\\LAMDA_SSL\\Download\\cifar-10-python',labeled_size=4000,stratified=False,shuffle=True,download=False)\n```\n\nThe specific data in the dataset can be obtained by the parameters of the encapsulated dataset.\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n## Data Transformation\n\nTaking RandAugment[41] data augmentation as an example, firstly import the RandAugment class.\n\n```python\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\n```\n\nInstantiate a RandAugment class. the parameter 'n' is the number of random augmentations, the parameter 'm' is the magnitude of augmentation and the parameter 'num_bins' is the number of levels of magnitude division. This setting divides the augmentation into 10 levels, and uses the 10th level augmentation twice.\n\n```python\naugmentation=RandAugment(n=2,m=10,num_bins=10)\n```\n\nThen input data to complete data augmentation. There are two ways. you can call the fit_transform() method:\n\n```python\naugmented_X=augmentation.fit_transform(X)\n```\n\nYou can also call the \\_\\_call\\_\\_() method directly:\n\n```python\naugmented_X=augmentation(X)\n```\n\n## Pipeline Mechanism\n\nLAMDA-SSL supports the Pipeline mechanism. You can use multiple data processing methods for data processing in the form of pipelines.\nSuch as strong data augmentation and weak data augmentation in FixMatch algorithm.\n\n```python\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\n\nweak_augmentation = Pipeline([('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect')),\n                                ])\n\nstrong_augmentation = Pipeline([('RandAugment', RandAugment(n=2, m=5, num_bins=10, random=True)),\n                                  ('Cutout', Cutout(v=0.5, fill=(127, 127, 127))),\n                                  ('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                  ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect')),\n                                  ])\n```\n\nYou can directly call the fit_transform() method to complete data processing.\n\n```python\nweak_augmented_X=weak_augmentation.fit_transform(X)\nstrong_augmented_X=strong_augmentation.fit_transform(X)\n```\n\n## Train an Inductive Statistical Semi-Supervised classification Model\n\nTaking the SSGMM algorithm as an example, firstly import the BreastCancer data set. The parameter 'labeled_size' indicates the number(int) or ratio(float) of the labeled data set. The parameter 'stratified' and 'shuffle' respectively indicate whether the data set needs to be divided according to the class distribution and whether the data needs to be shuffled.\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0)\n```\n\nPreprocess the data.\n\n```python\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n```\n\nCall and initialize the SSGMM model.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.SSGMM import SSGMM\n\nmodel=SSGMM(tolerance=0.000001)\n```\n\nCall the fit() method for model training.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nMake predictions on test data.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nThe model performance can be evaluated by calling the accuracy evaluation metric from the evaluation module.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nperformance=Accuracy().scoring(test_y,result)\n```\n\nThe probability that samples belong to different classes can also be obtained by the 'predict_proba' method.\n\n```python\nscore_y=model.predict_proba(X=test_X)\n```\n\nThe model performance can be evaluated by calling the accuracy evaluation metric from the evaluation module.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nperformance=AUC(multi_class='ovo').scoring(test_y,pred_y,score_y)\n```\n\n## Train a Transductive Statistical Semi-Supervised Classification Model\n\nTaking the TSVM algorithm as an example, firstly import the BreastCancer data set. The parameter 'labeled_size' indicates the number(int) or ratio(float) of the labeled data set. The parameter 'stratified' and 'shuffle' respectively indicate whether the data set needs to be divided according to the class distribution and whether the data needs to be shuffled.\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\ndataset=BreastCancer(labeled_size=0.1, stratified=True,\nshuffle=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n```\n\nThe samples are preprocessed by sklearn's StandardScaler module.\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\nThen import and initialize TSVM algorithm, where the parameter 'Cl' represents the weight of the labeled samples and the parameter 'Cu' represents the weight of the unlabeled samples in the initial state. The parameter 'kernel' represents the kernel function used in the algorithm.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.TSVM import TSVM\nmodel=TSVM(Cl=15,Cu=0.0001,kernel='linear')\n```\n\nModel training can be done through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe prediction result is obtained by the predict() method. Since TSVM is a transductive model, the predict() method can not input new data.\n\n```python\npred_y=model.predict()\n```\n\nFinally, the accuracy evaluation index can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(unlabeled_y,pred_y)\n```\n\nYou can also choose to extend an transductive method to an inductive method, you need to set the parameter 'Transductive' to False.\n\n```python\ntest_X=dataset.test_X\npred_y=model.predict(X=test_X, Transductive=False)\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## Train a Multi-View Statistical Semi-Supervised Classification Model\n\nTaking the Co-Training algorithm as an example, firstly import the BreastCancer data set. The parameter 'labeled_size' indicates the number(int) or ratio(float) of the labeled data set. The parameter 'stratified' and 'shuffle' respectively indicate whether the data set needs to be divided according to the class distribution and whether the data needs to be shuffled.\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\ndataset=BreastCancer(labeled_size=0.1, stratified=True,\nshuffle=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n```\n\nThe samples are preprocessed by sklearn's StandardScaler module.\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\nView partitioning of data is required.\n\n```python\nfrom LAMDA_SSL.Split.ViewSplit import ViewSplit\n\nsplit_labeled_X = ViewSplit(labeled_X, shuffle=False)\nsplit_unlabeled_X = ViewSplit(unlabeled_X, shuffle=False)\nsplit_test_X = ViewSplit(test_X, shuffle=False)\n```\n\nThen import and initialize Co-Training algorithm.\n\n```python\nfrom sklearn.svm import SVC\nfrom LAMDA_SSL.Algorithm.Classification.Co_Training import Co_Training\nSVM=SVC(C=1.0,kernel='linear',probability=True,gamma='auto')\nmodel=Co_Training(base_estimator=SVM,s=(len(labeled_X)+len(unlabeled_X))//10)\n```\n\nModel training can be completed through the fit() method, and data from different views can be passed in separately.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nIt is also possible to pass data under different views through a parameter in the form of a dictionary or a list.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe prediction result is obtained by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the accuracy evaluation index can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## Train a Statistical Semi-Supervised Regression Model\n\nTaking the CoReg algorithm as an example, firstly import the Boston data set. The parameter 'labeled_size' indicates the number(int) or ratio(float) of the labeled data set. The parameter 'stratified' and 'shuffle' respectively indicate whether the data set needs to be divided according to the class distribution and whether the data needs to be shuffled.\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\ndataset=Boston(labeled_size=0.3,test_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\nThe samples are preprocessed by sklearn's StandardScaler module.\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\nThen import and initialize the CoReg algorithm.\n\n```python\nfrom LAMDA_SSL.Algorithm.Regression.CoReg import CoReg\nmodel=CoReg()\n```\n\nModel training can be done through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe prediction results can be obtained by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the mean square error evaluation metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\n\nperformance = Mean_Squared_Error().scoring(test_y, pred_y)\n```\n\n## Train a Statistical Semi-Supervised Clustering Model\n\nTake Constrained Seed k Means and Constrained k Means algorithms as examples. Firstly import the Wine dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.Wine import Wine\ndataset = Wine(labeled_size=0.2, stratified=True, shuffle=True,random_state=0,default_transforms=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n```\n\nThe samples are preprocessed by sklearn's StandardScaler module.\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\nThen import and initialize the Constrained Seed k Means algorithm.\n\n```python\nfrom LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means import Constrained_Seed_k_means\n\nmodel = Constrained_Seed_k_means(k=3)\n```\n\nPerform model training.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nIt is also possible to import and initialize Constrained k means algorithm.\n\n```python\nfrom LAMDA_SSL.Algorithm.Clustering.Constrained_k_means import Constrained_k_means\n\nmodel = Constrained_k_means(k=3)\n```\n\nBut for Constrained k Means algorithm, the supervision information is the must-link and cannot-link constraints. If there are constraints provided by users, the training can be performed directly.\n\n```python\nmodel.fit(X=X,ml=ml,cl=cl)\n```\n\nIf there is no constraint information provided by users and only part of the labels are available, the labels can be used to construct the constraints for training.\n\n```python\nml=[]\ncl=[]\nfor i in range(labeled_X.shape[0]):\n    for j in range(i+1,labeled_X.shape[0]):\n        if labeled_y[i]==labeled_y[j]:\n            ml.append({i,j})\n        else:\n            cl.append({i,j})\nmodel.fit(X=np.vstack((labeled_X,unlabeled_X)), ml=ml,cl=cl)\n```\n\nOr directly input data in the form of a standard interface, and the labeled data will be automatically converted into constraints inside the model.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe clustering results can be obtained by the predict() method.\n\n```python\npred_y=model.predict()\n```\n\nThe results of clustering can be evaluated using external metrics or internal metrics. The external metrics such as Fowlkes Mallows Score require reference clustering results(true labels). The internal metrics such as Davies Bouldin Score require features of samples.\n\n```python\nfrom LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score import Fowlkes_Mallows_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score import Davies_Bouldin_Score\n\nouter_performence=Fowlkes_Mallows_Score()(y_true=np.hstack([labeled_y, unlabeled_y]),clusters=pred_y)\n\ninner_performence=Davies_Bouldin_Score()(clusters=pred_y,X=np.vstack((labeled_X,unlabeled_X)))\n```\n\n## Train a Deep Semi-Supervised Model with Default Configuration\n\nTake the FixMatch algorithm as an example. Firstly import and initialize the CIFAR10 dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\cifar-10-python',\n                  labeled_size=4000, stratified=False, shuffle=True, download=True)\n```\n\nObtain the specific data in the dataset by accessing the parameters of the encapsulated dataset.\n\n```\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\nThen import and initialize the algorithm. The parameter 'threshold' represents the confidence threshold for selecting unlabeled samples to participate in the unsupervised loss calculation. The parameter 'lamda_u' represents the weight of the unsupervised loss. The parameter 'mu' represents the ratio of unlabeled samples to labeled samples in each batch. The parameter 'T' represents the sharpening temperature for soft labels. The parameter 'device' represents the device for training the model. The parameters 'epoch', 'num_it_epoch', and 'num_it_total' represent the number of model training epochs, the number of iterations in each epoch, and the total number of iterations in all epochs, respectively. You only need to set two of the three to automatically complete the other. Other parameters and modules are set by default.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,mu=7,T=0.5,epoch=1,num_it_epoch=2**20,num_it_total=2**20，device='cuda:0')\n```\n\nModel training can be done through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe prediction for the test samples can be completed by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the accuracy evaluation index can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## Train a Custom-Configured Deep Semi-Supervised Model\n\nFor components in pytorch, such as Dataset, Sampler, BatchSampler, Dataloader, Network, Optimizer, Scheduler and Parallel, LAMDA-SSL supports users to flexibly replace or customize these components according to needs.\n\nTake the FixMatch algorithm as an example.\nFirst import and initialize the CIFAR10 dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\cifar-10-python',\n                  labeled_size=4000, stratified=False, shuffle=True, download=True)\n```\n\nObtain the specific data in the dataset by accessing the parameters of the encapsulated dataset.\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\nIn pytorch, all specific data needs to be encapsulated in a Dataset to build a Dataloader. The Dataset module of pytorch should contain specific data, data transformation methods and index functions, but the specific data is unknown when the model is initialized until the fit() method is called. Therefore, in LAMDA-SSL, when the algorithm is initialized, Dataset as a deep learning component, is only a container that does not contain specific data. After the data is input by the fit() method, DeepModelMixin module will automatically construct the complete Dataset. Therefore, users can flexibly replace the Dataset module when the algorithm is initialized without being affected by the specific data.\n\n```python\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\npre_transform = ToImage()\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                      ('Normalization', Normalization(mean=dataset.mean, std=dataset.std))])\nlabeled_dataset = LabeledDataset(pre_transform=pre_transform, transform=transform)\nunlabeled_dataset = UnLabeledDataset(pre_transform=pre_transform, transform=transform)\nvalid_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\ntest_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n```\n\nLAMDA-SSL also supports users to select data sampling methods according to their needs. For example, you can randomly sample the labeled data and unlabeled data during training and sequentially sample the validation and testing data. The parameter 'replacement' represents whether to repeat the sampling. The parameter 'num_samples' represents the total number of samples. The number of samples of unlabeled data can be unspecified. After the ratio of unlabeled samples to labeled samples is determined when the algorithm is initialized, DeepModelMixin module will complete the processing.\n\n```python\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n```\n\nFor users who are accustomed to using BatchSampler, LAMDA-SSL also supports.\n\n```python\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nlabeled_batchsampler=BatchSampler(batch_size=64,drop_last=True)\n```\n\nDataloader can also be replaced according to user needs and is not affected by datasets and samplers. The parameter 'batch_size' represents the size of each batch of data. The parameter 'num_workers' represents the number of sub-processes that load data. The parameter 'drop_last' represents whether to discard data less than one batch. The parameter 'batch_size' of unlabeled dataloader can also be temporarily unspecified.\n\n```python\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n```\n\nLAMDA-SSL supports users to replace or customize the neural network structure according to their own needs. The neural network is built by pytorch and inherits torch.nn.Module. Here, a WideResNet network with a depth of 28 and a width factor of 2 is used as the backbone network of the FixMatch classifier.\n\n```python\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n```\n\nLAMDA-SSL supports users to use different optimizers to complete the training of deep semi-supervised models, and unlike pytorch, it is not necessary to input the model parameters to be optimized when the optimizer is initialized, only the basic information of the optimizer can be determined to avoid The coupling between the optimizer and the network structure.\n\n```python\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n```\n\nThe scheduler can also be replaced arbitrarily without relying on the optimizer and network structure. Subsequent processing is done internally by DeepModelMixin.\n\n```python\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\n\nscheduler = CosineAnnealingLR(eta_min=0, T_max=2 ** 20)\n```\n\nFor algorithms with data augmentations, users can freely change the data augmentation process to adapt to different task scenarios and data types. Like data transformation, LAMDA-SSL's augmentation module supports both sklearn's Pipeline mechanism and pytorch's Compose mechanism. For cases that require multiple augmentation methods, such as weak augmentation and strong augmentation in FixMatch, you only need to use lists, tuples or dictionaries in python to pass parameters and the algorithm will complete the processing internally.\n\n```python\nfrom LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\n\nweak_augmentation = Pipeline([('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect'))])\nstrong_augmentation = Pipeline([('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                  ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect')),\n                                  ('RandAugment', RandAugment(n=2, m=5, num_bins=10, random=True)),\n                                  ('Cutout', Cutout(v=0.5, fill=(127, 127, 127)))])\naugmentation = {\n    'weak_augmentation': weak_augmentation,\n    'strong_augmentation': strong_augmentation\n}\n```\n\nThrough the above components configuration, users can flexibly replace components and parameters and combine them into the FixMatch algorithm, so that the same algorithm can be used in a wider range of application scenarios.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,labeled_sampler=labeled_sampler,unlabeled_sampler=unlabeled_sampler,valid_sampler=valid_sampler,test_sampler=test_sampler,labeled_dataloader=labeled_dataloader,unlabeled_dataloader=unlabeled_dataloader,valid_dataloader=valid_dataloader,test_dataloader=test_dataloader,augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,epoch=1,num_it_epoch=2**20,num_it_total=2**20,device='cuda:0',mu=7,T=0.5,weight_decay=5e-4,threshold=0.95,lambda_u=1.0,ema_decay=0.999)\n```\n\nIn order to simplify the parameters, the four training data modules: TrainDataset, TrainBatchSampler, TrainSampler and TrainDataloader can also be used to replace the labeled data module and the unlabeled data module. Training data modules include a labeled data module and an unlabeled data module and both are managed and scheduled. Even if the parameters of the labeled data module and the unlabeled data module are passed separately, they will be automatically merged into the training data module by DeepModelMixin. This is because the training data module additionally has the function of adjusting the ratio of the number of samples and batch size between labeled data and unlabeled data. In most scenarios of semi-supervised learning, when the labeled data module and the unlabeled data module are the same except for the sampling number and batch size, only one module needs to be initialized and the number of samples and the size of each batch are the same as the labeled data module.\n\n```python\ntrain_dataset=TrainDataset(transform=dataset.transform,unlabeled_transform=dataset.unlabeled_transform)\ntrain_batchsampler=BatchSampler(batch_size=64,drop_last=True)\ntrain_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\ntrain_dataloader=TrainDataLoader(num_workers=0)\n```\n\nFor the case where there are other inconsistencies between the labeled data module and the unlabeled data module except the number of samples and batch size, parameters can be passed through lists, tuples, or dicts.\n\n```python\ntrain_dataset=TrainDataset(transform=dataset.transform,unlabeled_transform=dataset.unlabeled_transform)\ntrain_batchsampler=BatchSampler(batch_size=100,drop_last=True)\ntrain_sampler={\n    \"Labeled\":RandomSampler(replacement=True,num_samples=540*100),\n    \"Unlabeled\":RandomSampler(replacement=False)\n}\ntrain_dataloader=TrainDataLoader(num_workers=0)\n```\n\nThe model can be configured through the training data module replacing the original method of configuring through the labeled data module and unlabeled data.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(train_dataset=train_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,train_sampler=train_sampler,valid_sampler=valid_sampler,test_sampler=test_sampler,train_dataloader=train_dataloader,valid_dataloader=valid_dataloader,test_dataloader=test_dataloader,augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,epoch=1,num_it_epoch=2**20,num_it_total=2**20,device='cuda:0',mu=7,T=0.5,weight_decay=5e-4,threshold=0.95,lambda_u=1.0,ema_decay=0.999)\n```\n\nModel training can be done through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe fit() method supports direct input of complete labeled datasets and unlabeled datasets for training.\n\n```python\nmodel.fit(X=dataset.labeled_dataset,unlabeled_X=dataset.unlabeled_dataset)\n```\n\nThe fit() method also supports passing in the entire training dataset directly.\n\n```python\nmodel.fit(X=dataset.train_dataset)\n```\n\nThe prediction for the test samples can be completed by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nThe predict() method supports directly passing in the dataset to be predicted.\n\n```python\npred_y=model.predict(X=dataset.test_dataset)\n```\n\nFinally, the accuracy evaluation metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## Train a Deep Semi-Supervised Text Classification Model\n\nTaking FixMatch algorithm as an example, firstly import and initialize the SST2 dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Text.SST2 import SST2\ndataset=SST2(root='..\\Download\\SST2',stratified=True,shuffle=True,download=False,length=50,default_transforms=True)\n```\n\nObtain the specific data in the dataset by accessing the parameters of the encapsulated dataset.\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\nInitialize the data processing flow and the dataset class. Here, Tokenizer is used for word segmentation in the preprocessing flow of text data. After the text is augmented, the length of the text is adjusted firstly. Then the Glove word vectors is used to map words into indexs according to the dictionary. Finally the index are converted to torch.Tensor.\n\n```python\nfrom LAMDA_SSL.Transform.Text.Vocab import Vocab\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\nfrom LAMDA_SSL.Transform.Text.AdjustLength import AdjustLength\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.Text.GloVe import Glove\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\npre_transform = Tokenizer('basic_english')\nvectors = Glove()\ntransform = Pipeline([('Adjust_length', AdjustLength(length=dataset.length)),\n                      ('Vocab', Vocab(vectors.vec)),\n                      ('ToTensor', ToTensor())])\nlabeled_dataset = LabeledDataset(pre_transform=pre_transform, transform=transform)\n\nunlabeled_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n\nvalid_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n\ntest_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n```\n\nSpecific weak data augmentation and strong data augmentation for text data. Weak data augmentation randomly swaps adjacent words in the text and the parameter 'n' represents the number of exchanges. Strong data augmentation replaces words in the text. The words with lower TF-IDF values have a higher probability of being replaced.\n\n```python\nfrom LAMDA_SSL.Augmentation.Text.RandomSwap import RandomSwap\nfrom LAMDA_SSL.Augmentation.Text.TFIDFReplacement import TFIDFReplacement\nweak_augmentation=RandomSwap(n=1)\n\nstrong_augmentation=TFIDFReplacement(text=labeled_X,p=0.7)\n\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n```\n\nUse the TextRCNN model as the backbone network.\n\n```python\nfrom LAMDA_SSL.Network.TextRCNN import TextRCNN\nnetwork=TextRCNN(n_vocab=vectors.vec.vectors.shape[0],embedding_dim=vectors.vec.vectors.shape[1],\n                 pretrained_embeddings=vectors.vec.vectors,len_seq=50,\n                 num_classes=2)\n```\n\nImport and initialize FixMatch algorithm.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,augmentation=augmentation,network=network,mu=7,T=0.5,weight_decay=5e-4,threshold=0.95,lambda_u=1.0,epoch=1,num_it_epoch=2**20,device='cuda:0')\n```\n\nModel training can be done through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe prediction of the test samples can be completed by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the accuracy evaluation metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## Train a Deep Semi-Supervised Regression Model\n\nTake PiModelReg algorithm as an example. Firstly import the Boston dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\ndataset=Boston(test_size=0.3,labeled_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\n```\n\nObtain the specific data in the dataset by accessing the parameters of the encapsulated dataset.\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\nPreprocess the Data with StandardScaler.\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n```\n\nInitialize the data processing flow and initialize the dataset module.\n\n```python\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\ntransform=ToTensor()\nlabeled_dataset=LabeledDataset(transform=transform)\n\nunlabeled_dataset=UnlabeledDataset(transform=transform)\n\nvalid_dataset=UnlabeledDataset(transform=transform)\n\ntest_dataset=UnlabeledDataset(transform=transform)\n```\n\nGaussian noise is used as the data augmentation method.\n\n```python\nfrom LAMDA_SSL.Augmentation.Tabular.Noise import Noise\n\naugmentation = Noise(noise_level=0.01)\n```\n\nThe multilayer perceptron is used as the backbone neural network.\n\n```python\nnetwork=MLP_Reg(hidden_dim=[100,50,10],activations=[nn.ReLU(),nn.ReLU(),nn.ReLU()],dim_in=labeled_X.shape[-1])\n```\n\nImport and initialize the PiModelReg algorithm.\n\n```python\nmodel=PiModelReg(labeled_dataset=labeled_dataset,\n                unlabeled_dataset=unlabeled_dataset,\n                valid_dataset=valid_dataset,\n                test_dataset=test_dataset,\n                augmentation=augmentation,\n                network=network,lambda_u=0.1,\n                warmup=0.4,mu=1,weight_decay=5e-4,\n                epoch=1,num_it_epoch=4000,device='cuda:0')\n```\n\nModel training can be done through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe prediction of the test samples can be completed by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the mean square error metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error \nscore=Mean_Squared_Error().scoring(test_y,pred_y)\n```\n\n## Train a Deep Generative Model\n\nTaking the ImprovedGAN algorithm as an example, firstly import the MNIST dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.Mnist import Mnist\ndataset=Mnist(root='..\\Download\\mnist',labeled_size=6000,shuffle=True,download=False,random_state=0,default_transforms=True)\n```\n\nGet specific data by accessing the dataset properties.\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n```\n\nImport and initialize ImprovedGAN algorithm.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.ImprovedGAN import ImprovedGAN\nImprovedGAN=ImprovedGAN(lambda_u=1,dim_z=100,dim_in=(28,28),mu=1,epoch=100,num_it_epoch=540,num_it_total=540*100,device='cuda:0')\n```\n\nTrain the model.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nMake predictions on test data.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the accuracy evaluation metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\nCompared with other deep semi-supervised learning methods, deep generative methods can generate data by calling the generate() method.\n\n```python\nfake_X=model.generate(100)\n```\n\n## Train a Deep Graph-based Model\n\nThe graph data in LAMDA-SSL is encapsulated using the torch_geometric.data.data class of torch_geometric. This class contains information such as node features, node labels, and edges between nodes in the graph. Whether the nodes in the graph data are labeled, used for training, validation or testing are divided in the form of masks. Taking the GCN algorithm as an example, firstly import and initialize the Cora dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Graph.Cora import Cora\ndataset=Cora(labeled_size=0.2,root='..\\Download\\Cora',random_state=0,default_transforms=True)\n```\n\nGet the graph data and preprocess it.\n\n```python\nfrom LAMDA_SSL.Transform.Graph.NormalizeFeatures import NormalizeFeatures\n\ntransform = NormalizeFeatures\ndata = dataset.transform.fit_transform(dataset.data)\n```\n\nSet the optimizer.\n\n```python\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\noptimizer=Adam(lr=0.01)\n```\n\nImport and initialize the GCN model.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.GCN import GCN\nmodel=GCN(num_features=1433,\n          normalize=True,\n          epoch=2000,\n          weight_decay=5e-4,\n          optimizer=optimizer)\n```\n\nUsers can directly input the encapsulated graph data to train the model.\n\n```python\nmodel.fit(X=data)\n```\n\nThe fit() method also supports separate parameters for various types of information in the graph and the algorithm will automatically complete the encapsulation of the graph data.\n\n```python\nmodel.fit(X=data.X,y=data.y,edge_index=data.edge_index,\n          labeled_mask=data.labeled_mask,\n          unlabeled_mask=data.unlabeled_mask,val_mask=data.val_mask,\n          test_mask=data.test_mask)\n```\n\nThe prediction is done by the predict() method. For the graph data with the test_mask attribute after encapsulation, it is no longer necessary to pass new parameters.\n\n```python\npred_y=model.predict()\n```\n\nFor graph data that does not have the test_mask attribute after encapsulation the nodes to be predicted need to be re-specified, the mask of the test nodes should be input.\n\n```python\npred_y=model.predict(X=test_mask)\n```\n\nFinally, the accuracy evaluation metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(data.y[data.test_mask],pred_y)\n```\n\n## Train a Distributed Deep Semi-Supervised Model\n\nTaking FixMatch algorithm as an example, firstly import and initialize the CIFAR10 dataset.\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\cifar-10-python',\n                  labeled_size=4000, stratified=False, shuffle=True, download=True)\n```\n\nObtain the specific data in the dataset by accessing the parameters of the encapsulated dataset.\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\nThen import the DataParallel module. There is an example training with a single machine and multiple cards. The parameter 'device_ids' represents the available GPU devices. The parameter 'output_device' represents the GPU device where the model output results are stored.\n\n```python\nfrom LAMDA_SSL.Distributed.DataParallel import DataParallel\nparallel=DataParallel(device_ids=['cuda:0','cuda:1'],output_device='cuda:0')\n```\n\nThen import and initialize the FixMatch algorithm and set up the parallel module.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,mu=7,T=0.5,device='cuda:0',parallel=parallel)\n```\n\nThe prediction is done by the predict() method.\n\n```python\npred_y=model.predict(X=test_X)\n```\n\nFinally, the accuracy evaluation metric can be called from the evaluation module to evaluate the model performance.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## Model Evaluation\n\nLAMDA-SSL supports the evaluation of model performance using the prediction results after the prediction is over.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\npred_y=model.predict(X=test_X)\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\nIt is also possible to use evaluation metrics as parameters of the model, so that multiple evaluation metrics can be stored in tuples, lists or dicts.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nevaluation={\n    'Accuracy':Accuracy(),\n    'Top_5_Accuracy':Top_k_Accurary(k=5),\n    'Precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_Matrix':Confusion_Matrix(normalize='true')\n}\n```\n\nInitialize the model containing the evaluation module.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,ema_decay=0.999,device='cuda:0',evaluation=evaluation)\n```\n\nModel training is performed through the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nThe model is evaluated directly through the evaluate() method of the model. The evaluation results in the form of a tuple, list or dict corresponds to the evaluation module of the model are finally returned.\n\n```python\nperformance=model.evaluate(X=test_X,y=test_y)\n```\n\nThe evaluate() method also supports direct input of the complete dataset.\n\n```python\nperformance=model.evaluate(X=dataset.test_dataset)\n```\n\nThe prediction results can be obtained by accessing the y_pred attribute.\n\n```python\ny_pred=model.y_pred\n```\n\n## Model Validation\n\nFor deep semi-supervised learning models, LAMDA-SSL supports validation during model training.\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nevaluation={\n    'Accuracy':Accuracy(),\n    'Top_5_Accuracy':Top_k_Accurary(k=5),\n    'Precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_Matrix':Confusion_Matrix(normalize='true')\n}\n```\n\nInitializes a deep semi-supervised model with an evaluation module. Users can set the parameter 'eval_epoch' and the model will be validation every 'eval_epoch' epochs.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,  ema_decay=0.999,weight_decay=5e-4,epoch=100,num_it_epoch=1000,num_it_total=100*1000,eval_epoch=10,device='cuda:0',evaluation=evaluation)\n```\n\nYou can also set the parameter 'eval_it', and the model will be validated every 'eval_it' iterations.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,  ema_decay=0.999,weight_decay=5e-4,epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cuda:0',evaluation=evaluation)\n```\n\nThe validation of the model during the training process can be completed by inputting the validation data while calling the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n```\n\nThe full validation dataset can also be input directly.\n\n```python\nmodel.fit(X=dataset.labeled_dataset,unlabeled_X=dataset.unlabeled_dataset,valid_X=dataset.valid_dataset)\n```\n\nFor the depth graph model, the nodes to be validated can be specified in the form of masks.\n\n```python\nmodel.fit(data,valid_X=data.val_mask)\n```\n\nThe validation results can be obtained by accessing the valid_performance parameter.\n\n```python\nvalid_result=model.valid_performance\n```\n\nIf you need to track the validation results in real time during the model training process, you can set the parameter 'verbose' to True to output the validation results in real time and you can set the parameter 'file' to complete output redirection.\n\n```python\nfile = open(\"../Unused/Result/ImprovedGAN_MNIST.txt\", \"w\")\nmodel = FixMatch(threshold=0.95, lambda_u=1.0, T=0.5, mu=7, ema_decay=0.999, weight_decay=5e-4, epoch=1,\n                 num_it_epoch=2 ** 20, num_it_total=2 ** 20, eval_it=2000, device='cuda:0', evaluation=evaluation,\n                 verbose=True, file=file)\n```\n\n## HyperParameters Search\n\nLAMDA-SSL supports the parameter search mechanism in sklearn.\nFirst initialize a model with incomplete parameters.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=Fixmatch(train_dataset=train_dataset,test_dataset=test_dataset,\n               train_dataloader=train_dataloader,test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,epoch=1,num_it_epoch=2,num_it_total=2,\n               optimizer=optimizer,scheduler=scheduler,device='cpu',eval_it=1,\n               mu=7,T=1,weight_decay=0,evaluation=evaluation,train_sampler=train_sampler,\n               test_sampler=test_sampler,train_batch_sampler=train_batchsampler,ema_decay=0.999)\n```\n\nSet the parameters to be searched in the form of a dictionary.\n\n```python\nparam_dict = {\"threshold\": [0.7, 1],\n              \"lambda_u\":[0.8, 1]\n              }\n```\n\nHyperParameters search is performed in a random search manner.\nFirst, initialize the search module.\n\n```python\nfrom sklearn.model_selection import RandomizedSearchCV\nrandom_search = RandomizedSearchCV(model, param_distributions=param_dict,n_iter=1, cv=4,scoring='accuracy')\n```\n\nStart the hyperparameters search process.\n\n```python\nrandom_search.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nFinally, the search results are obtained by the 'best_params_' parameter.\n\n```python\nbest_params=random_search.best_params_\n```\n\n## Save and Load Models\n\nSemi-supervised learning models can be saved and loaded using pickle.\n\nSet the path.\n\n```python\npath='../save/FixMatch.pkl'\n```\n\nSave the model.\n\n```python\nwith open(path, 'wb') as f:\n    pickle.dump(model, f)\n```\n\nLoad the model.\n\n```python\nwith open(path, 'rb') as f:\n    model = pickle.load(f)\n```\n\n## Custom Data\n\nIn addition to the datasets provided by LAMDA-SSL, users can easily use their own datasets. When the dataset needs to be divided, the DataSplit function of the Split module in LAMDA-SSL can be called.\n\n```python\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\n\nlabeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=X, y=y, size_split=self.labeled_size,\n                                                            stratified=self.stratified, shuffle=self.shuffle,\n                                                            random_state=self.random_state)\n```\n\nIn statistical semi-supervised learning algorithms, the preprocessed data can be directly passed into the fit() method.\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nIn deep semi-supervised learning algorithms, if data augmentations are not required, the preprocessed data can also be directly passed into fit(). Users can also specify the data processing method by setting parameters such as pre_transform, transform, transforms, target_transform in the dataset, so that the corresponding processing can be performed when the data is loaded. Among them, transforms represents the transformation flow for processing X and y at the same time, target_transform represents the transformation flow for processing y, and pre_transform and transform respectively represent the transformation flowfor processing X before and after data augmentation respectively. For example, for CIFAR10 dataset, the original data is in numpy.ndarray format, which needs to be converted into image format before data augmentation. After the image is augmented, it needs to be converted into torch.Tensor format and normalized.\n\n```python\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\ntransforms=None\ntarget_transform=None\npre_transform=ToImage()\ntransform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\nunlabeled_transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\ntest_transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\nvalid_transform=Pipeline([('ToTensor',ToTensor(dtype='float',image=True)),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\n```\n\nUsers can pass a custom data transformation method into the dataset module, as a component in deep learning. the model will load and process the original data during the learning process.\n\n```python\nlabeled_dataset=LabeledDataset(pre_transform=pre_transform,transforms=transforms,\n                               transform=transform,target_transform=target_transform)\nunlabeled_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=unlabeled_transform)\nvalid_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=valid_transform)\ntest_dataset=UnlabeledDataset(pre_transform=pre_transform,transform=test_transform)\n\nmodel=FixMatch(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset)\n```\n\nWhen data augmentation is required, users can customize the augmentation method for their own data. When multiple data augmentations are required, tuple, list or dict can be used to pass parameters.\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\nmodel=FixMatch(augmentation=augmentation)\n```\n\n## Custom Data Transformation\n\nCustom data transformation methods need to inherit the LAMDA_SSL.Transform.Transformer class. Similar to the data transformation module in sklearn, only two methods fit() and transform() need to be implemented. For some transformers that do not require the fit() process, the fit() method can be omitted. Take Normalization as an example.\n\n```python\nfrom torchvision.transforms import transforms\nfrom LAMDA_SSL.Base.Transformer import Transformer\n\n\nclass Normalization(Transformer):\n    def __init__(self, mean=None, std=None):\n        super().__init__()\n        self.mean = mean\n        self.std = std\n        self.normalize = transforms.Normalize(mean=self.mean, std=self.std)\n\n    def transform(self, X):\n        X = self.normalize(X.float())\n        return X\n```\n\n## Custom Sampler\n\nThe custom sampler needs to inherit the BaseSampler class and implement the init_sampler() method which needs the real dataset as input and returns a torch.utils.data.sampler.Sampler object. Take RandomSampler as an example.\n\n```python\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom torch.utils.data import sampler\n\n\nclass RandomSampler(BaseSampler):\n    def __init__(self, replacement: bool = False,\n                 num_samples=None, generator=None):\n        super().__init__()\n        self.replacement = replacement\n        self.num_samples = num_samples\n        self.generator = generator\n\n    def init_sampler(self, data_source):\n        return sampler.RandomSampler(data_source=data_source, replacement=self.replacement,num_samples=self.num_samples, generator=self.generator)\n```\n\nLAMDA_SSL supports the use of the BatchSampler class. Users need to implement the init_sampler() method which can convert a torch.utils.data.sampler.Sampler object into a torch.utils.data.sampler.BatchSampler object.\n\n```python\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nimport torch.utils.data.sampler as torchsampler\n\n\nclass BatchSampler(BaseSampler):\n    def __init__(self, batch_size: int, drop_last: bool):\n        super().__init__()\n        self.batch_size = batch_size\n        self.drop_last = drop_last\n\n    def init_sampler(self, sampler):\n        return torchsampler.BatchSampler(sampler=sampler, batch_size=self.batch_size, drop_last=self.drop_last)\n```\n\n## Custom Optimizer\n\nThe custom sampler needs to inherit the BaseOptimizer class. Ussers need to implement the init_optimizer() method which needs the parameters to be optimized as input, and outputs a torch.optim.optimizer.Optimizer object. Take the Adam optimizer as an example.\n\n```python\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nfrom torch.optim import adam\n\n\nclass Adam(BaseOptimizer):\n    def __init__(self, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, amsgrad=False):\n        self.lr = lr\n        self.betas = betas\n        self.eps = eps\n        self.weight_decay = weight_decay\n        self.amsgrad = amsgrad\n        defaults = dict(lr=lr, betas=betas, eps=eps,\n                        weight_decay=weight_decay, amsgrad=amsgrad)\n        super().__init__(defaults=defaults)\n\n    def init_optimizer(self, params):\n        return adam.Adam(params=params, lr=self.lr, betas=self.betas, eps=self.eps,\n                         weight_decay=self.weight_decay, amsgrad=self.amsgrad)\n\n```\n\n## Custom Learning Rate Scheduler\n\nCustom schedulers need to inherit the LAMDA_SSL.Scheduler.BaseScheduler class,\nAnd you need to implement the init_scheduler() method, input a torch.optim.optimizer.Optimizer object, and output a torch.optim.lr_scheduler._LRScheduler object. Take StepLR as an example.\n\n```python\nfrom torch.optim import lr_scheduler\nclass BaseScheduler:\n    def __init__(self, last_epoch=-1, verbose=False):\n        self.last_epoch=last_epoch\n        self.verbose=verbose\n\n    def init_scheduler(self,optimizer):\n        return lr_scheduler._LRScheduler(optimizer,last_epoch=self.last_epoch,verbose=self.verbose)\n```\n\nLAMDA-SSL supports the LambdaLR scheduler in pytorch. It needs to inherit the LambdaLR class and implement the _lr_lambda method which requires the current number of steps to be input and returns the learning rate change factor. The scheduling rule is $new_{lr}=lambda(current\\_step)\\times initial_{lr}$。Take Linear_Warmup as an example.\n\n```python\nfrom LAMDA_SSL.Base.LambdaLR import LambdaLR\n\n\nclass Linear_Warmup(LambdaLR):\n    def __init__(self,\n                 num_training_steps,\n                 num_warmup_steps=0,\n                 start_factor=0,\n                 end_factor=1,\n                 last_epoch=-1,\n                 verbose=False):\n        self.start_factor = start_factor\n        self.end_factor = end_factor\n        self.num_warmup_steps = num_warmup_steps\n        self.num_training_steps = num_training_steps\n        self.verbose = verbose\n        super().__init__(lr_lambda=self._lr_lambda, last_epoch=last_epoch, verbose=self.verbose)\n\n    def _lr_lambda(self, current_step):\n        if current_step > self.num_warmup_steps:\n            return self.start_factor + float(self.num_training_steps - current_step)\n            / (self.num_training_steps - self.num_warmup_steps) * (self.end_factor - self.start_factor)\n        return 1\n```\n\n## Custom Loss Function\n\nThe loss functions implemented by LAMDA-SSL all inherit the torch.nn.Module module and the forward() method needs to be implemented to return the calculation result of the loss function.\n\n```python\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch\n\nclass Consistency(nn.Module):\n    def __init__(self,reduction='mean'):\n        super().__init__()\n        self.reduction = reduction\n\n    def forward(self,logits_1,logits_2):\n        assert logits_1.size() == logits_2.size()\n        return F.mse_loss(torch.softmax(logits_1, dim=-1), torch.softmax(logits_2, dim=-1), reduction='mean')\n```\n\n## Custom Evaluation Metrics\n\nCustom classification evaluation metrics need to inherit the ClassifierEvaluation class. The scoring method needs to be implemented and the real labels, hard and soft labels predicted by the model are input for scoring. Take the accuracy metric as an example.\n\n```python\nfrom LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import accuracy_score\nfrom LAMDA_SSL.utils import partial\n\n\nclass Accuracy(ClassifierEvaluation):\n    def __init__(self, normalize=True, sample_weight=None):\n        super().__init__()\n        self.normalize = normalize\n        self.sample_weight = sample_weight\n        self.score = partial(accuracy_score, normalize=self.normalize, sample_weight=self.sample_weight)\n\n    def scoring(self, y_true, y_pred=None, y_score=None):\n        return self.score(y_true=y_true, y_pred=y_pred)\n```\n\nCustom Regression evaluation metrics need to inherit the RegressorEvaluation class. The scoring method needs to be implemented and the real labels and results predicted by the model are input for scoring. Take the accuracy metric as an example.\n\n```python\nfrom LAMDA_SSL.Base.RegressorEvaluation import RegressorEvaluation\nfrom sklearn.metrics import mean_squared_error\nfrom LAMDA_SSL.utils import partial\n\nclass Mean_Squared_Error(RegressorEvaluation):\n    def __init__(self,sample_weight=None, multioutput=\"uniform_average\",squared=True):\n        super().__init__()\n        self.sample_weight=sample_weight\n        self.multioutput=multioutput\n        self.squared=squared\n        self.score=partial(mean_squared_error,sample_weight=self.sample_weight,\n                           multioutput=self.multioutput,squared=squared)\n    def scoring(self,y_true,y_pred=None):\n        return self.score(y_true=y_true,y_pred=y_pred)\n```\n\nThe custom cluster evaluation metrics need to inherit the ClusterEvaluation class. The scoring method needs to be implemented and the real labels, clustering results and sample features are input for scoring. Take the Davies_Bouldin metric as an example.\n\n```python\nfrom LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\nfrom sklearn.metrics import davies_bouldin_score\nclass Davies_Bouldin_Score(ClusterEvaluation):\n    def __init__(self):\n        super().__init__()\n        self.score=davies_bouldin_score\n\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(labels=clusters,X=X)\n```\n\n## Custom Statistical Semi-Supervised Learning Algorithms\n\nUsers can customize new semi-supervised learning algorithms through LAMDA-SSL and can build custom learners by combining InductiveEstimator, TransductiveEstimator, DeepModelMixin and other modules of LAMDA-SSL and ClassifierMixin, RegressorMixin, ClusterMixin and other modules of sklearn, which can inherit Functions corresponding to each module.\n\nFor the statistical semi-supervised learning algorithm. You can directly implement the fit() method and the predict() method. You can further implement the predict_proba() method to obtain the soft labels predicted by the model. Take SSGMM algorithm as an example.\n\n```python\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nfrom LAMDA_SSL.utils import class_status\nimport LAMDA_SSL.Config.SSGMM as config\n\nclass SSGMM(InductiveEstimator,ClassifierMixin):\n    def __init__(self,tolerance=config.tolerance, max_iterations=config.max_iterations, num_classes=config.num_classes,\n                 evaluation=config.evaluation,verbose=config.verbose,file=config.file):\n        self.num_classes=num_classes\n        self.tolerance=tolerance\n        self.max_iterations=max_iterations\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def normfun(self,x, mu, sigma):\n        k = len(x)\n        dis = np.expand_dims(x - mu, axis=0)\n        pdf = np.exp(-0.5 * dis.dot(np.linalg.inv(sigma)).dot(dis.T)) / np.sqrt(\n            ((2 * np.pi) ** k) * np.linalg.det(sigma))\n        return pdf\n\n    def fit(self,X,y,unlabeled_X):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(y).num_classes\n        L=len(X)\n        U=len(unlabeled_X)\n        m=L+U\n        labele_set={}\n        for _ in range(self.num_classes):\n            labele_set[_]=set()\n        for _ in range(L):\n            labele_set[y[_]].add(_)\n        self.mu=[]\n        self.alpha=[]\n        self.gamma=np.empty((U,self.num_classes))\n        self.alpha = np.random.rand(self.num_classes)\n        self.alpha = self.alpha / self.alpha.sum()\n        self.mu = np.random.rand(self.num_classes, X.shape[1])\n        self.sigma = np.empty((self.num_classes, X.shape[1], X.shape[1]))\n        for i in range(self.num_classes):\n            self.sigma[i] = np.eye(X.shape[1])\n        for _ in range(self.max_iterations):\n            # E Step\n            pre=copy.copy(self.alpha)\n            for j in range(U):\n                _sum=0\n                for i in range(self.num_classes):\n                    _sum+=self.alpha[i]*self.normfun(unlabeled_X[j],self.mu[i],self.sigma[i])\n                for i in range(self.num_classes):\n                    self.gamma[j][i]=self.alpha[i]*self.normfun(unlabeled_X[j],self.mu[i],self.sigma[i])/_sum\n            # M step\n            for i in range(self.num_classes):\n                _sum_mu=0\n                _sum_sigma=np.zeros((X.shape[1],X.shape[1]))\n                _norm=0\n                _norm+=len(labele_set[i])\n                for j in labele_set[i]:\n                    _sum_mu+=X[j]\n                for j in range(U):\n                    _sum_mu+=self.gamma[j][i]*unlabeled_X[j]\n                    _norm+=self.gamma[j][i]\n                self.mu[i]=_sum_mu/_norm\n                self.alpha[i]=_norm/m\n                for j in labele_set[i]:\n                    _sum_sigma+=np.outer(X[j]-self.mu[i],X[j]-self.mu[i])\n                for j in range(U):\n                    _sum_sigma += self.gamma[j][i]*np.outer(unlabeled_X[j] - self.mu[i], unlabeled_X[j] - self.mu[i])\n                self.sigma[i]=_sum_sigma/_norm\n            isOptimal = True\n            for i in range(self.num_classes):\n                if abs((self.alpha[i] - pre[i])/pre[i])>self.tolerance:\n                    isOptimal=False\n            if isOptimal:\n                break\n        return self\n\n    def predict_proba(self,X):\n        y_proba=np.empty((len(X),self.num_classes))\n        for i in range(len(X)):\n            _sum=0\n            for j in range(self.num_classes):\n                _sum+=self.normfun(X[i],self.mu[j],self.sigma[j])\n            for j in range(self.num_classes):\n                y_proba[i][j]=self.normfun(X[i],self.mu[j],self.sigma[j])/_sum\n        return y_proba\n\n    def predict(self,X):\n        y_proba=self.predict_proba(X)\n        y_pred=np.argmax(y_proba, axis=1)\n        return y_pred\n```\n\n## Custom Deep Semi-Supervised Learning Algorithm\n\nFor deep semi-supervised learning models, users can implement the fit() method and predict() method by themselves, but this is too cumbersome. Many repetitive operations can be simplified by directly inheriting DeepModelMixin. DeepModelMixin module subdivides the training and prediction process of the deep learning model and provides a default processing mode for each subdivision process. Users only need to replace the changed parts to complete the customization of the algorithm with a small amount of code.\n\nThe init_model() method needs to complete the neural network initialization, including placing the network on the specified device or initializing distributed processing module if necessary.\n\n```python\ndef init_model(self):\n    if self.device is not None and self.device is not 'cpu':\n        torch.cuda.set_device(self.device)\n    self._network=self._network.to(self.device)\n    if self._parallel is not None:\n        self._network=self._parallel.init_parallel(self._network)\n```\n\nThe init_ema() method is mainly aimed at the situation where the exponential moving averaging mechanism needs to be used for the model parameters. When the 'ema_decay' parameter is not None, an EMA model will be initialized.\n\n```python\ndef init_ema(self):\n    if self.ema_decay is not None:\n        self.ema=EMA(model=self._network,decay=self.ema_decay)\n        self.ema.register()\n    else:\n        self.ema=None\n```\n\nThe init_optimizer() method initializes the optimizer used in model training. The model parameters to be optimized are specified in the process.\n\n```python\ndef init_optimizer(self):\n    if isinstance(self._optimizer,BaseOptimizer):\n        no_decay = ['bias', 'bn']\n        grouped_parameters = [\n            {'params': [p for n, p in self._network.named_parameters() if not any(\n                nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\n            {'params': [p for n, p in self._network.named_parameters() if any(\n                nd in n for nd in no_decay)], 'weight_decay': 0.0}\n        ]\n        self._optimizer=self._optimizer.init_optimizer(params=grouped_parameters)\n```\n\nThe init_scheduler() method initializes the learning rate scheduler used in model training. The optimizer is specified in the process.\n\n```python\ndef init_scheduler(self):\n    if isinstance(self._scheduler,BaseScheduler):\n        self._scheduler=self._scheduler.init_scheduler(optimizer=self._optimizer)\n```\n\nThe init_epoch() method will adaptively complete the three parameters: 'epoch', 'num_it_epoch' and 'num_it_total'.\n\n```python\ndef init_epoch(self):\n    if self.num_it_epoch is not None and self.epoch is not None:\n        self.num_it_total=self.epoch*self.num_it_epoch\n    elif self.num_it_total is not None and self.epoch is not None:\n        self.num_it_epoch=ceil(self.num_it_total/self.epoch)\n    elif self.num_it_total is not None and self.num_it_epoch is not None:\n        self.epoch=ceil(self.num_it_total/self.num_it_epoch)\n```\n\nThe init_augmentation() method initializes the augmentation method of the model.\n\n```python\ndef init_augmentation(self):\n    if self._augmentation is not None:\n        if isinstance(self._augmentation, dict):\n            self.weak_augmentation = self._augmentation['augmentation'] \\\n                if 'augmentation' in self._augmentation.keys() \\\n                else self._augmentation['weak_augmentation']\n            if 'strong_augmentation' in self._augmentation.keys():\n                self.strong_augmentation = self._augmentation['strong_augmentation']\n        elif isinstance(self._augmentation, (list, tuple)):\n            self.weak_augmentation = self._augmentation[0]\n            if len(self._augmentation) > 1:\n                self.strong_augmentation = self._augmentation[1]\n        else:\n            self.weak_augmentation = copy.deepcopy(self._augmentation)\n        if self.strong_augmentation is None:\n            self.strong_augmentation = copy.deepcopy(self.weak_augmentation)\n```\n\nThe init_transform() method initializes the transformation method of the data and adds data augmentation to the data processing flow. The add_transform() method represents adding a new processing method to the labeled samples. The data processing of LAMDA-SSL can be regarded as a two-dimensional list. When dim=0, it means adding horizontal data processing, that is, adding a new independent data processing process on the basis of the original data processing, which will cause the original data to be copied one more time for the new process and the data obtained after processing will also be one more copy than the original. When dim=1, it means adding vertical data processing and the data will be further processed after the original processing and the data will not be copied. The parameters 'x' and 'y' are used to indicate the position of the newly added data processing method in the two-dimensional list. The add_unlabeled_transform() method represents adding a new processing method to the unlabeled samples, which is the same as the add_transform() method.\n\nTaking the ICT algorithm as an example, the implementation of its init_transform() method is:\n\n```python\ndef init_transform(self):\n    if self.weak_augmentation is not None:\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation, dim=1, x=0, y=0)\n```\n\nThe original processing flow for both labeled samples and unlabeled samples is:\n\n```python\n[\n    [Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nAfter adding weak data augmentation in the first position of the first data processing flow, both the data processing flow for labeled data and unlabeled data become:\n\n```python\n[\n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nIn this way, during data loading, weak augmentation and original transformation are sequentially performed to the data and the number of data copies does not increase.\n\n```python\nlb_X = lb_X\nulb_X = ulb_X\n```\n\nTaking the FixMatch algorithm as an example, the implementation of its init_transform() method is:\n\n```python\ndef init_transform(self):\n    self._train_dataset.add_unlabeled_transform(copy.deepcopy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n    self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n    self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n    self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n```\n\nThe original processing flow for both labeled samples and unlabeled samples is:\n\n```python\n[\n    [Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nFixMatch algorithm adds weak data augmentation to the first data processing flow with labeled data. Its data processing flow becomes:\n\n```python\n[\n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nFixMatch algorithm replicates the first data processing flow of unlabeled data forming two independent processing flows and adds weak data augmentation and strong data augmentation respectively. Its data processing flow becomes:\n\n```python\n[\n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])],\n    \n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),('RandAugment',RandAugment(n=2,m=10,num_bins=10)),('Cutout',Cutout(v=0.5,fill=(127, 127, 127)))]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nThis increases the number of copies of unlabeled data when the data is loaded.\n\n```python\nlb_X = lb_X\nw_ulb_X, s_ulb_X = ulb_X[0], ulb_X[1]\n```\n\nThe fit() method of DeepModelMixin consists of 5 parts: init_train_dataset(), init_train_dataloader(), start_fit(), fit_epoch_loop(), end_fit().\n\n```python\ndef fit(self,X=None,y=None,unlabeled_X=None,valid_X=None,valid_y=None):\n    self.init_train_dataset(X,y,unlabeled_X)\n    self.init_train_dataloader()\n    self.start_fit()\n    self.fit_epoch_loop(valid_X,valid_y)\n    self.end_fit()\n    return self\n```\n\nThe init_train_dataset() method encapsulates the data input by the fit() method. A packaged training dataset is obtained through this method.\n\n```python\ndef init_train_dataset(self,X=None,y=None,unlabeled_X=None, *args, **kwargs):\n    if isinstance(X,TrainDataset):\n        self._train_dataset=X\n    elif isinstance(X,Dataset) and y is None:\n        self._train_dataset.init_dataset(labeled_dataset=X, unlabeled_dataset=unlabeled_X)\n    else:\n        self._train_dataset.init_dataset(labeled_X=X, labeled_y=y,unlabeled_X=unlabeled_X)\n```\n\nThe init_train_dataloader() method obtains a complete data loader based on the training data set, training data sampler, and the ratio of unlabeled data to labeled data in each batch.\n\n```python\ndef init_train_dataloader(self):\n    if self._train_dataloader is not None:\n        self._labeled_dataloader,self._unlabeled_dataloader=self._train_dataloader.init_dataloader(dataset=self._train_dataset,\n                                                                                    sampler=self._train_sampler,\n                                                                                    batch_sampler=self._train_batch_sampler,\n                                                                                    mu=self.mu)\n    else:\n        self._train_dataloader=TrainDataLoader(labeled_dataloader=self._labeled_dataloader,unlabeled_dataloader=self._unlabeled_dataloader)\n        self._train_sampler={'labeled':self._labeled_sampler,'unlabeled':self._unlabeled_sampler}\n        self._train_batch_sampler={'labeled':self._labeled_batch_sampler,'unlabeled':self._unlabeled_batch_sampler}\n        self._labeled_dataloader, self._unlabeled_dataloader = self._train_dataloader.init_dataloader(\n            dataset=self._train_dataset,\n            sampler=self._train_sampler,\n            batch_sampler=self._train_batch_sampler,\n            mu=self.mu)\n```\n\nThe start_fit() method is an operation that deep learning needs to complete before training through iterations.\n\n```python\ndef start_fit(self, *args, **kwargs):\n    self._network.zero_grad()\n    self._network.train()\n```\n\nThe fit_epoch_loop() method is the process of iterative training of the model. The model performance needs to be verified when the conditions are met. This method is the process of the outer loop for each round of training. The inner training process of the same round can be divided into three parts: start_fit_epoch(), fit_batch_loop(), end_fit_epoch().\n\n```python\ndef fit_epoch_loop(self,valid_X=None,valid_y=None):\n    self.valid_performance={}\n    self.it_total = 0\n    for self._epoch in range(1,self.epoch+1):\n        self.it_epoch=0\n        if self.it_total >= self.num_it_total:\n            break\n        self.start_fit_epoch()\n        self.fit_batch_loop(valid_X,valid_y)\n        self.end_fit_epoch()\n        if valid_X is not None and self.eval_epoch is not None and self._epoch % self.eval_epoch==0:\n            self.evaluate(X=valid_X,y=valid_y,valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n\n    if valid_X is not None and self.epoch%self.eval_epoch!=0:\n        self.evaluate(X=valid_X, y=valid_y, valid=True)\n        self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n```\n\nThe start_fit_epoch() method is an operation that needs to be performed before each epoch training starts. There are no operations by default. It can be added according to algorithm requirements.\n\n```python\ndef start_fit_epoch(self, *args, **kwargs):\n    pass\n```\n\nThe fit_batch_loop() method is the inner loop for each round of training. In each step of the loop, a batch of data is processed and the model is validated when the conditions are met. It also includes three methods: start_fit_batch(), train(), and end_fit_batch().\n\n```python\ndef fit_batch_loop(self,valid_X=None,valid_y=None):\n    for (lb_idx, lb_X, lb_y), (ulb_idx, ulb_X, _) in zip(self._labeled_dataloader, self._unlabeled_dataloader):\n        if self.it_epoch >= self.num_it_epoch or self.it_total >= self.num_it_total:\n            break\n        self.start_fit_batch()\n        lb_idx = to_device(lb_idx,self.device)\n        lb_X = to_device(lb_X,self.device)\n        lb_y = to_device(lb_y,self.device)\n        ulb_idx = to_device(ulb_idx,self.device)\n        ulb_X  = to_device(ulb_X,self.device)\n        train_result = self.train(lb_X=lb_X, lb_y=lb_y, ulb_X=ulb_X, lb_idx=lb_idx, ulb_idx=ulb_idx)\n        self.end_fit_batch(train_result)\n        self.it_total += 1\n        self.it_epoch += 1\n        if self.verbose:\n            print(self.it_total,file=self.file)\n        if valid_X is not None and self.eval_it is not None and self.it_total % self.eval_it == 0:\n            self.evaluate(X=valid_X, y=valid_y,valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n```\n\nThe start_fit_batch() method is the operation before each batch of training starts. There are no operations by default. It can be added according to algorithm requirements.\n\n```python\ndef start_fit_batch(self, *args, **kwargs):\n    pass\n```\n\nThe train() method is the process of training each batch of data and returns the training results in the form of tuples, which is a process that all deep semi-supervised learning algorithms should have.\n\n```python\ndef train(self,lb_X=None,lb_y=None,ulb_X=None,lb_idx=None,ulb_idx=None,*args,**kwargs):\n    raise NotImplementedError\n```\n\nThe end_fit_batch() method is an operation after each batch of training. It concludes two parts by default: get_loss() and optimize().\n\n```python\ndef end_fit_batch(self, train_result,*args, **kwargs):\n    self.loss = self.get_loss(train_result)\n    self.optimize(self.loss)\n```\n\nThe get_loss() method is a process in which the model calculates the loss function according to the training results, and returns the loss calculation results, which is also a process that all deep semi-supervised learning algorithms should have.\n\n```python\ndef get_loss(self,train_result,*args,**kwargs):\n    raise NotImplementedError\n```\n\nThe optimize() method is a process of backpropagation, parameter optimization and learning rate scheduling after the loss is obtained.\n\n```python\ndef optimize(self,loss,*args,**kwargs):\n    self._network.zero_grad()\n    loss.backward()\n    self._optimizer.step()\n    if self._scheduler is not None:\n        self._scheduler.step()\n    if self.ema is not None:\n        self.ema.update()\n```\n\nThe end_fit_epoch() method is an operation that needs to be performed at the end of each epoch training. There are no operations by default. It can be added according to algorithm requirements.\n\n```python\ndef end_fit_epoch(self, *args, **kwargs):\n    pass\n```\n\nThe end_fit() method is what needs to be done at the end of the fit() method. There are no operations by default and it can be added according to algorithm requirements.\n\n```python\ndef end_fit(self, *args, **kwargs):\n    pass\n```\n\nThe predict() method of DeepModelMixin is divided into 5 parts: init_estimate_dataset(), init_estimate_dataloader(), start_predict(), predict_batch_loop() and end_predict().\n\n```python\n@torch.no_grad()\ndef predict(self,X=None,valid=False):\n    self.init_estimate_dataset(X,valid)\n    self.init_estimate_dataloader(valid)\n    self.start_predict()\n    self.predict_batch_loop()\n    self.end_predict()\n    return self.y_pred\n```\n\nThe predict_proba() method for classification tasks has the same structure as the predict() method, but returns a different value.\n\n```python\n@torch.no_grad()\ndef predict_proba(self,X=None,valid=False):\n    self.init_estimate_dataset(X,valid)\n    self.init_estimate_dataloader(valid)\n    self.start_predict()\n    self.predict_batch_loop()\n    self.end_predict()\n    return self.y_score\n```\n\nThe init_estimate_dataset() method needs to encapsulate the data to be estimated and finally form a complete dataset.\n\n```python\ndef init_estimate_dataset(self, X=None,valid=False):\n    if valid:\n        if isinstance(X,Dataset):\n            self._valid_dataset=X\n        else:\n            self._valid_dataset=self._valid_dataset.init_dataset(X=X)\n    else:\n        if isinstance(X,Dataset):\n            self._test_dataset=X\n        else:\n            self._test_dataset=self._test_dataset.init_dataset(X=X)\n```\n\nThe init_estimate_dataloader() method is a process to obtain the data loader for estimation based on the estimated dataset and estimated sampler.\n\n```python\ndef init_estimate_dataloader(self,valid=False):\n    if valid:\n        self._estimate_dataloader=self._valid_dataloader.init_dataloader(self._valid_dataset,sampler=self._valid_sampler,batch_sampler=self._valid_batch_sampler)\n    else:\n        self._estimate_dataloader=self._test_dataloader.init_dataloader(self._test_dataset,sampler=self._test_sampler,batch_sampler=self._test_batch_sampler)\n```\n\nThe start_predict() method is what the algorithm needs to do when the predict() method starts.\n\n```python\ndef start_predict(self, *args, **kwargs):\n    self._network.eval()\n    if self.ema is not None:\n        self.ema.apply_shadow()\n    self.y_est = torch.Tensor().to(self.device)\n```\n\nThe predict_batch_loop() method is a process of predicting for all the samples to be predicted by looping. It includes three methods: start_predict_batch(), estimate() and end_predict_batch().\n\n```python\ndef predict_batch_loop(self):\n    with torch.no_grad():\n        for idx,X,_ in self._estimate_dataloader:\n            self.start_predict_batch()\n            idx=to_device(idx,self.device)\n            X=X[0] if isinstance(X,(list,tuple)) else X\n            X=to_device(X,self.device)\n            _est=self.estimate(X=X,idx=idx)\n            _est = _est[0] if  isinstance(_est,(list,tuple)) else _est\n            self.y_est=torch.cat((self.y_est,_est),0)\n            self.end_predict_batch()\n```\n\nThe start_predict_batch() method is the operation before each batch of data prediction starts.\nThere are no operations by default. It can be added according to algorithm requirements.\n\n```python\ndef start_predict_batch(self, *args, **kwargs):\n    pass\n```\n\nThe estimate() method is the process of making predictions for each batch of data.\n\n```python\n@torch.no_grad()\ndef estimate(self, X, idx=None, *args, **kwargs):\n    outputs = self._network(X)\n    return outputs\n```\n\nThe end_predict_batch() method is the operation after each batch of data is predicted.\nThere are no operations by default and it can be added according to algorithm requirements.\n\n```python\ndef end_predict_batch(self, *args, **kwargs):\n    pass\n```\n\nThe end_predict() method is the operation that needs to be performed at the end of the predict() method. It includes the get_predict_result() method.\n\n```python\ndef end_predict(self, *args, **kwargs):\n    self.y_pred = self.get_predict_result(self.y_est)\n    if self.ema is not None:\n        self.ema.restore()\n    self._network.train()\n```\n\nThe get_predict_result() method is the process for obtaining the prediction results according to the network's outputs.\n\n```python\n@torch.no_grad()\ndef get_predict_result(self, y_est, *args, **kwargs):\n    if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n        y_score = Softmax(dim=-1)(y_est)\n        max_probs, y_pred = torch.max(y_score, dim=-1)\n        y_pred = y_pred.cpu().detach().numpy()\n        self.y_score = y_score.cpu().detach().numpy()\n        return y_pred\n    else:\n        self.y_score = y_est.cpu().detach().numpy()\n        y_pred = self.y_score\n        return y_pred\n```\n\nThe evaluate() method is the evaluation process of the model. When the parameter 'valid' is True, it is used for verification during model training, otherwise it is used for performance evaluation after the model training process.\n\n```python\n@torch.no_grad()\ndef evaluate(self,X,y=None,valid=False):\n\n    if isinstance(X,Dataset) and y is None:\n        y=getattr(X,'y')\n\n    self.y_pred=self.predict(X,valid=valid)\n    self.y_score=self.y_score\n\n    if self.evaluation is None:\n        return None\n    elif isinstance(self.evaluation,(list,tuple)):\n        performance=[]\n        for eval in self.evaluation:\n            if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n            else:\n                score = eval.scoring(y,self.y_pred)\n            performance.append(score)\n            if self.verbose:\n                print(score, file=self.file)\n        self.performance = performance\n        return performance\n    elif isinstance(self.evaluation,dict):\n        performance={}\n        for key,val in self.evaluation.items():\n            if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n            else:\n                performance[key] = val.scoring(y, self.y_pred)\n            if self.verbose:\n                print(key,' ',performance[key],file=self.file)\n            self.performance = performance\n        return performance\n    else:\n        if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n        else:\n            performance = self.evaluation.scoring(y, self.y_pred)\n        if self.verbose:\n            print(performance, file=self.file)\n        self.performance=performance\n        return performance\n```\n\nTaking FixMatch algorithm as an example, since it inherits a large number of modules in DeepModelMixin. Only the three methods: init_transform(), train() and get_loss() are changed to complete the complete implementation of FixMatch algorithm. It can be seen that it is very convenient to customize a deep semi-supervised learning algorithm under the framework of LAMDA-SSL.\n\n```python\nimport copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Config.FixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_supervised_loss\nimport torch\n\n\nclass FixMatch(InductiveEstimator, DeepModelMixin, ClassifierMixin):\n    def __init__(self,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        DeepModelMixin.__init__(self, train_dataset=train_dataset,\n                                valid_dataset=valid_dataset,\n                                labeled_dataset=labeled_dataset,\n                                unlabeled_dataset=unlabeled_dataset,\n                                test_dataset=test_dataset,\n                                train_dataloader=train_dataloader,\n                                valid_dataloader=valid_dataloader,\n                                test_dataloader=test_dataloader,\n                                augmentation=augmentation,\n                                network=network,\n                                train_sampler=train_sampler,\n                                train_batch_sampler=train_batch_sampler,\n                                valid_sampler=valid_sampler,\n                                valid_batch_sampler=valid_batch_sampler,\n                                test_sampler=test_sampler,\n                                test_batch_sampler=test_batch_sampler,\n                                labeled_dataloader=labeled_dataloader,\n                                unlabeled_dataloader=unlabeled_dataloader,\n                                labeled_sampler=labeled_sampler,\n                                unlabeled_sampler=unlabeled_sampler,\n                                labeled_batch_sampler=labeled_batch_sampler,\n                                unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                epoch=epoch,\n                                num_it_epoch=num_it_epoch,\n                                num_it_total=num_it_total,\n                                eval_epoch=eval_epoch,\n                                eval_it=eval_it,\n                                mu=mu,\n                                weight_decay=weight_decay,\n                                ema_decay=ema_decay,\n                                optimizer=optimizer,\n                                scheduler=scheduler,\n                                device=device,\n                                evaluation=evaluation,\n                                parallel=parallel,\n                                file=file,\n                                verbose=verbose\n                                )\n        self.lambda_u = lambda_u\n        self.threshold = threshold\n        self.T = T\n        self.weight_decay = weight_decay\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.deepcopy(self.train_dataset.unlabeled_transform), dim=0, x=1)\n        self._train_dataset.add_transform(self.weak_augmentation, dim=1, x=0, y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation, dim=1, x=0, y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation, dim=1, x=1, y=0)\n\n    def train(self, lb_X, lb_y, ulb_X, lb_idx=None, ulb_idx=None, *args, **kwargs):\n        w_lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        w_ulb_X, s_ulb_X = ulb_X[0], ulb_X[1]\n        batch_size = w_lb_X.shape[0]\n        inputs = torch.cat((w_lb_X, w_ulb_X, s_ulb_X))\n        logits = self._network(inputs)\n        lb_logits = logits[:batch_size]\n        w_ulb_logits, s_ulb_logits = logits[batch_size:].chunk(2)\n        train_result = (lb_logits, lb_y, w_ulb_logits, s_ulb_logits)\n        return train_result\n\n    def get_loss(self, train_result, *args, **kwargs):\n        lb_logits, lb_y, w_ulb_logits, s_ulb_logits = train_result\n        sup_loss = Cross_Entropy(reduction='mean')(logits=lb_logits, targets=lb_y)\n        pseudo_label = torch.softmax(w_ulb_logits.detach() / self.T, dim=-1)\n        max_probs, targets_u = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold).float()\n        unsup_loss = (Cross_Entropy(reduction='none')(s_ulb_logits, targets_u) * mask).mean()\n        loss = Semi_supervised_loss(lambda_u=self.lambda_u)(sup_loss, unsup_loss)\n        return loss\n```\n\n# User Guide\n\nLAMDA-SSL implements up to 30 semi-supervised learning algorithms, including 12 statistical machine learning algorithms and 18 deep learning algorithms, providing users with a variety of choices.\n\n## Statistical Semi-supervised Learning\n\nLAMDA-SSL contains 12 semi-supervised learning algorithms based on statistical machine learning models (as shown in Figure 9), among which the algorithms used for classification tasks include generative method SSGMM, semi-supervised support vector machine methods TSVM, LapSVM, graph-based methods Label Propagation, Label Spreading, divergence-based methods Co-Training, Tri-Training, ensemble methods SemiBoost, Assemble; the algorithms used for regression tasks include CoReg; the algorithms used for clustering tasks include Constrained K Means, Constrained Seed K Means.\n\n### Generative Model\n\nGenerative semi-supervised learning methods are based on generative models, which assume that data is generated from a potential distribution. Generative methods establish the relationship between samples and generative model parameters. In semi-supervised generative methods, labels are regarded as the latent variables of the model, The expectation-maximization (EM) algorithm can be used for maximum likelihood estimation.\n\n#### SSGMM\n\nSSGMM[4] model was proposed by Shahshahani et al. SSGMM is a semi-supervised Gaussian mixture model. It is assumed that data is generated by a Gaussian mixture model, that is, the marginal distribution of samples can be expressed as the result of mixing several Gaussian distributions together, and each Gaussian distribution is given a weight. SSGMM maps the feature distribution of each class to a Gaussian mixture component. For each labeled instance, the Gaussian mixture component corresponding to its class is known. For each unlabeled instance, the Gaussian mixture component is represented by a probability distribution, and it can be classified into the class corresponding to the Gaussian mixture component with the highest probability. SSGMM assumes that the samples obey the assumption of independent and identical distribution, and its likelihood function is the product of joint probabilities of all labeled examples and marginal probabilities of all unlabeled data samples. The maximum likelihood estimation is used to maximize the likelihood function to get the parameters of the generative model including the variance, mean, and weight of each part of the Gaussian mixture model with the highest probability of co-occurrence of labeled data and unlabeled data. Since this method has unobservable hidden variables corresponding labels of unlabeled samples, it cannot directly get maximum likelihood parameters, so SSGMM adopts the EM algorithm to solve this problem. The EM algorithm is divided into two steps. In E step, conditional distribution or expectation of the unobserved data are obtained according to the current parameters and the observable data. In the SSGMM model, this step uses the Bayesian formula to get the conditional distribution of the labels of the unlabeled samples according to the observed samples and the parameters of the current model. The M-step makes a maximum likelihood estimation of the model parameters according to the value of the currently observed variable and the expectation or probability distribution of the latent variable, that is, the original The hidden variables are unknown and the maximum likelihood estimation cannot be performed. After the E step, the expectation or conditional probability distribution of the hidden variables is obtained, and the maximum likelihood estimation becomes feasible. In the SSGMM model, this step uses the observed labeled samples and labels, unlabeled samples and class conditional distributions obtained in step E update the parameters of the Gaussian mixture model. Step E and step M are carried out alternately in an iterative form until convergence, which can realize the simultaneous use of labeled data and unlabeled data to train a Gaussian mixture model and the classifier based on this Gaussian mixture model can be obtained through the Bayesian formula.\n\n### Semi-supervised Support Vactor Machine\n\nSupport vector machine is one of the most representative algorithms in the field of machine learning. This class of algorithms treats the binary classification problem as finding a suitable partitioning hyperplane in the feature space. In the case of linear separability, among all the hyperplanes that can complete the correct classification, the optimal dividing hyperplane should be located in the middle of the samples from different classes, which can improve the robustness of the model for predicting unknown samples. In each class, the sample closest to the hyperplane is called the support vector. Support vectors of different classes are equidistant from the hyperplane. The purpose of the support vector machine algorithm is to find the hyperplane closest to its corresponding support vectors. However, in real tasks, there are often no hyperplanes that can correctly divide all training samples. Even if there are, it is most likely due to overfitting. Therefore, a class of support vector machine methods introduces Soft Margin mechanism , which allows the hyperplane to not necessarily classify all samples correctly, but adds a penalty for misclassifying samples in the optimization objective.\n\nSemi-supervised support vector machine is a generalization of the support vector machine algorithm in the field of semi-supervised learning. The semi-supervised support vector machine introduces a low-density assumption, that is, the learned hyperplane not only needs to separate the classifications as much as possible based on the labeled samples, but also needs to pass through the low-density regions of the distribution of all samples as much as possible. It make reasonable use of the unlabeled samples. LAMDA-SSL includes two semi-supervised SVM methods: TSVM and LapSVM.\n\n#### TSVM\n\nTSVM[5] was proposed by Joachims et al. TSVM is the most basic transductive semi-supervised support vector machine method. TSVM needs to infer labels of unlabeled samples and find a dividing hyperplane that maximizes the distance from support vectors. Since the labels assigned to the unlabeled samples are not necessarily real labels, the unlabeled samples and the labeled samples cannot be treated the same in the initial stage of training. $C_l$ and $C_u$ are magnitudes of the penalty reflecting the importance attached to the labeled samples and the unlabeled samples. Since the number of possible situations where labels of all unlabeled samples may appear increases exponentially with the increase of the number of unlabeled samples, it is impossible to determine the labels of unlabeled samples in an exhaustive way to find the global optimal solution. The optimization goal of TSVM is to find an approximate solution using an iterative search method. Firstly an SVM is trained based on the labeled samples, and the SVM is used to predict the labels of unlabeled samples. Then $C_l \\ll C_u$ is initialized, and the iteration is started. In the iterative process, all the samples are used to solve the new hyperplane. TSVM algorithm continuously finds pairs of unlabeled heterogeneous samples that may be mispredicted and exchange labels and retrain the SVM model until no more qualified pairs can be found. The importance of unlabeled samples is increased by doubling the value of $C_u$ in each iteration. Iteration continues until $C_u$ is equal to $ C_l$. Finally, the prediction results of the unlabeled samples obtained by the final SVM model and the transductive process is completed.\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/TSVM.png\" >\n\n<br>\nFigure 11[5]: TSVM Algorithm\n</div>\n\n<!-- ##### <font color=blue size=56>LapSVM</font> -->\n#### LapSVM\n \nLapSVM[6] was proposed by Belkin et al. LapSVM is based on the manifold assumption. The classical SVM algorithm seeks to maximize the margin between the dividing hyperplane and support vectors, which only considers the distribution of samples in the feature space. However, in practical applications, samples in high-dimensional space are often distributed on low-dimensional Riemannian manifolds. Classical SVM based on original feature space tends to ignore the essential characteristics of samples. LapSVM adds a manifold regularization term to the optimization objective of SVM for learning the essential distribution of samples. LapSVM builds a graph model using all samples, obtains the weight matrix of the graph model through the similarity between the features of the samples and calculates its Laplace matrix. The Laplace regularization term guides the predicted results of the adjacent samples in the graph to be as consistent as possible. Unlike TSVM, LapSVM only penalizes the misclassification of labeled samples, but uses all samples when building a graph model, so that unlabeled samples participate in the learning process by the distribution of samples on the manifold.\n\n### Graph Based Method\n\nThe graph-based semi-supervised learning method represents the data set as a graph model with samples as nodes and relationships among samples as edges. In semi-supervised learning, there are labeled data and unlabeled data, so some points have labels, while others haven't. Graph-based transductive semi-supervised learning can be regarded as the process of label propagation or spreading in the graph.\n\n#### Label Propagation\n\nLabel Propagation[7] was proposed by Zhu et al. Label Propagation uses samples as nodes, and the relationship between the samples as edges. The graph can be constructed fully connected or based on k-nearest neighbors. The purpose of Label Propagation algorithm is to propagate the labels from labeled data to unlabeled data through the graph. The optimization goal of Label Propagation is the Laplacian consistency, that is the weighted mean square error of the difference of labels between pairs of adjacent nodes. Since the labels of labeled samples are fixed, Label Propogation only needs to solve the labels of unlabeled data to minimize the optimization goal. So the model's predictions for adjacent points on the graph should be as consistent as possible. Label Propagation makes the partial derivative of the optimization objective to the labels of unlabeled samples to be 0 and the optimal solution can be obtained. It has been proved that this closed-form optimal solution obtained by direct calculation is consistent with the final convergence result of infinite and continuous iterations. An accurate solution can be obtained through direct derivation, without simulating the process of label propagation and performing multiple iterations for convergence, which is the advantage of Label Propagation over other graph based semi-supervised learning methods.\n\n#### Label Spreading\n\n Label Spreading[8] was proposed by Zhou et al. Different from Label Propagation algorithm in which the labels of the labeled samples are fixed during the spreading process to protect the influence of the real labels on the model, Label Spreading penalizes misclassified labeled samples rather than banning it completely. For the existence of data noise, Label Prapogation has certain limitations and does not performs well. An labels in Label Propagation algorithm can only flow to unlabeled nodes, which may block some paths that need to be propagated through labeled nodes, which limits the propagation of information in the graph. Label Spreading algorithm enables labels to be broadcast to all adjacent nodes to improve this problem.  There are two optimization goals for Label Spreading. The first is the same as that of Label Propagation, but there is no restriction that the model's prediction results for labeled samples must be equal to its true label. The second is the prediction loss for labeled data with a penalty parameter as its weight. Due to different optimization goals, Label Propagation has a closed-form solution, while Label Spreading needs to be solved iteratively. In each iteration, a trade-off parameter is required to weight spreading results and initial labels of samples as the current prediction results.\n\n### Disagreement Based Method\n\nDisagreement-based semi-supervised learning methods depend on multiple learners with significant divergence and use the disagreement between learners to utilize unlabeled data. Such methods are less affected by model assumptions, non-convexity of loss function and data scale problems. These methods are simple and effective and have solid theoretical foundation relatively.\n\n<!-- #### Self-Training\n\nSelf-Training[9] was proposed by Yarowsky et al. The Self-Training is the most classical wrapper method. It is an iterative method. Firstly, a supervised classifier is trained with labeled data. Then in each round of iteration, the current learner is used to make prediction on unlabeled samples to obtain its pseudo labels. Unlabeled samples with their pseudo labels whose confidence higher than a certain threshold are combined  with labeled dataset to form a new mixed dataset. Lately a new classifier trained on the mixed data set is used in the next iteration process. The training pocess of Self-Traing is so convenient that any supervised learner which provides soft labels can be used. Self-Training provides a basis for subsequent research on other wrapper methods. -->\n\n\n#### Co-Training\n\nCo-Training[10] was proposed by Blum et al. In Co-Training, two basic learners are used to cooperate with each other to assist each other's training. For unlabeled samples with high confidence on one learner, Co-Training will pass them and their pseudo-labels to another learner, through this form of interaction, the knowledge learned on one learner is passed on to another learner. Due to the difference between the two base learners, their learning difficulty for same samples is different. Co-Training effectively takes advantage of this difference, so that a learner can not only use its own confident pseudo-labels, but also use another learner's confident pseudo-labels to increase the utilization of unlabeled data. Finally the two learners are ensembled to be used for prediction. In order to make the two base learners have a certain difference, Co-Training adopts the multi-view assumption, that is, models trained based on different feature sets should have the same prediction results for the same samples. Co-Training divides the features of the samples into two sets, which are used as observations of the samples from two different views. The training data of the two learners in the initial state are only labeled data in different views. In the initial state, the training datasets of the two learners are only labeled dataset in different views. In the iterative process, Unlabeled samples with high pseudo-label confidence on one learner are added to the training datasets of two learners at the same time, which will be used for the next round of training. The iteration continues until the predictions of both learners no longer change.\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/Co-Training.png\" >\n\n<br>\n\nFigure 12[3]: Co-Training Algorithm\n</div>\n\n#### Tri-Training\n\nTri-Training[11] is proposed by Zhou et al. Because multi-learner training methods such as Co-Training must require differences between basic learners, such as different data views or different models. However, in practical applications, there may only be a single view of data, and artificially cutting the original data will lose the information of the relationship between the features in different views. The division method for views requires expert knowledge because wrong division may lead to serious performance degradation. The use of different models for co-training requires setting up multiple supervised learners. Considering that the advantage of wrapper methods over other semi-supervised learning methods is that the supervised learning algorithm can be directly extended to semi-supervised learning tasks, so there is often only one supervised learning algorithm in the scenarios where the wrapper methods are used. Designing additional supervised learning algorithms loses the convenience of wrapper methods. Tri-Training solves this problem from the perspective of data sampling. Only one supervised learning algorithm is used, and the dataset is randomly sampled multiple times to generate multiple different training datasets to achieve the purpose of learning to get multiple different models. In other wrapper methods, the model's confidence in unlabeled samples is used to decide whether to incorporate unlabeled data into the training data set. However, in some cases, the model may be overconfident in the misclassification, resulting in a large deviation. Tri-Training uses three base learners for training. During the training process of one base learner, for unlabeled samples, the other two base learners can be used to judge whether they should be added in the training dataset. If in one iteration, the common prediction error rate of the two learners is low and they have the same prediction result for the unlabeled sample, the unlabeled sample and its pseudo-label are more likely to produce positive effect to the current training base learner. Using the prediction consistency of the two models to determine whether to use unlabeled samples is more robust than using the confidence of only one model. In addition, in other wrapper methods, the selected unlabeled samples will always exist in the training dataset, which may cause the unlabeled samples that are mispredicted to have a lasting impact on the learner and can never be corrected. In Tri-Training, the unlabeled samples and their pseudo-labels used in each iteration of the algorithm are reselected. Tri-Training has a solid theoretical foundation and adds restrictions on the use of unlabeled data in each iteration based on the theoretical foundation. Strict constraints on the use of unlabeled data greatly increase the security of the semi-supervised model, which can effectively alleviate the problem of model performance degradation caused by erroneously using unlabeled data.\n\n### Ensemble Method\n\nIn the field of machine learning, the use of a single learner is likely to cause high deviation or variance due to underfitting or overfitting, resulting in insufficient model generalization ability. Ensemble learning combines multiple weak learners, which not only improves the model's ability to represent the hypothesis space, but also reduces the impact of errors caused by a single learner and improves the reliability of the model. In the field of semi-supervised learning, due to the addition of unlabeled data, using a single learner to set pseudo-labels for unlabeled samples further exacerbates the instability of a single learner and has a stronger reliance on effective ensemble learning methods.\n\n#### Assemble\n\nAssemble[12] is proposed by Bennett et al. Assemble is an extension of AdaBoost method in the field of semi-supervised learning. The Boosting method is an important method in ensemble learning. This method samples the data set through the prediction effect of the current ensemble learner. The sampling process will pay more attention to the samples whose results of the current ensemble learner is not good. This strategy enables the model to pay more attention to the samples with poor learning effect of the current ensmeble learner in each round of new weak learner learning process, and continuously improve the generalization ability and robustness of the model. AdaBoost is the most representative method in the Boosting methods. This method adaptively adjusts the sample weight according to the difference between the prediction results and the samples' real labels. The weak learners with higher accuracy have higher ensemble weights. ASSEMBLE promotes the AdaBoost method in the field of semi-supervised learning by adding pseudo-labels to unlabeled data. In the initial stage, the pseudo-labels of unlabeled samples are the labels of the closest labeled samples and the unlabeled data and labeled data have different weights. In the iterative process, the pseudo-labels of unlabeled data are updated to the prediction results of the ensemble learner in each round. As the iteration progresses, the effect of the ensemble learner is getting better and better and the pseudo-labels are more and more accurate, which further have a more beneficial impact on the ensemble learner.\n\n#### SemiBoost\n\nSemiBoost[13] are proposed by Mallapragada et al. Unlike Assemble, which only uses the difference between the prediction results of the model and the real labels or pseudo-labels to weight samples and does not consider the relationship between samples, SemiBoost is based on graph semi-supervised learning method, which points out that the similarity between samples also should be taken into consideration and a larger weight should be set for the samples with high similarity in feature space and high inconsistency in prediction results to other samples. The generalization ability and robustness of model are improved. Unlabeled samples play a greater role in this process. SemiBooost learns a new weak learner in each round of iteration. Its optimization objective consists of two items. The first item punishes the discrepancy between pseudo-labels of unlabeled samples and real labels of labeled samples which uses the similarity in feature space as weights. It is close to the effect of Label Propagation so that the model can obtain pseudo-labels of unlabeled samples according to the graph structure. The second term penalizes the prediction between unlabeled samples which uses the similarity within the unlabeled samples as weights. Te second item alleviates the impact of noise to the model.\n<div align=center>\n<img width=\"700px\"  src=\"./Imgs/SemiBoost.png\" >\n\n<br>\n\nFigure 13[13]: SemiBoost Algorithm\n\n</div>\n\n### Semi-supervised Regression\n\nMost of the current semi-supervised learning algorithms are designed for classification tasks and cannot be naturally extended to regression tasks. Only a few works are aimed at semi-supervised learning regression tasks. It is because in regression tasks, reasonable assumption are more difficult to be made compared to classification tasks. At present, there are few research results in this field and the semi-supervised regression task still has great demand and application value in real scenarios.\n\n#### CoReg\n\nCoReg[14] is proposed by Zhou et al. CoReg introduces the Co-Training algorithm into regression tasks. In wrapper methods originally used for classification, it is often assumed that samples with higher confidence will have a more positive impact on subsequent training. Some unlabeled samples and their pseudo-labels are selected as training data according to the confidence. However it is difficult to get the confidence in the regression task. CoReg solves this problem, thereby applying the Co-Training algorithm to regression tasks. CoReg uses the kNN model as the type of base learner. For two base learners, in order to maintain the difference between them, different orders are used to calculate the Minkowsky distance between samples in the k-nearest neighbor model. In order to measure the confidence of the model on the samples, for each unlabeled sample, the model first predicts the real-valued pseudo-label. CoReg then combines its pseudo-label with all the samples participating in the training process to retrain a learner and uses the mean squared error loss to evaluate to evaluate the impact of the sample on its k nearest neighbors. If the mean square error of these k-nearest neighbor nodes decreases, it means that adding the unlabeled sample is more likely to have a positive impact on subsequent training. Therefore, CoReg uses the difference between the mean square error before and after adding the unlabeled sample as the evaluation standard of confidence. The unlabeled sample with the highest confidence and its real value pseudo-label are added to the training dataset of another learner, thus completing the training process of Co-Training.\n\n### Semi-supervised Cluster\n\nUnlike semi-supervised classification and semi-supervised regression tasks, which use unlabeled data to assist the process of supervised learning, semi-supervised clustering tasks introduce supervision information to assist the process of unsupervised learning. Supervision information is not necessarily labeled data, but may also be other knowledge related to real labels. Due to the difference of supervised information, various semi-supervised clustering methods have also been proposed.\n\n#### Constrained k-means\n\nConstrained k-means[15] was proposed by Wagstaff et al. Based on k-means clustering algorithm, the algorithm introduces constraints called Must Link and Connot Link as supervision information. The Must Link constraint restricts that some samples must belong to the same cluster. The Connot Link constraint restricts that some samples must belong to different clusters. There is transfer mechanisms in constraints. For example, if A and B must be linked and B and C must be linked, then A and C must be linked and if A and B must be linked and B and C can not be linked, then A and C can not linked. K-means algorithm assigns a sample to the cluster whose cluster center is closest to the sample. Similarly, Constrained k-means also give priority to the cluster whose center is closest to the sample, but the difference is that Constrained k-means algorithm should judge whether the Must Link and Cannot Link constraints are violated between the sample and the samples which are already in the cluster. If violated, Constrained k-means will reconsider the next eligible cluster. If all clusters fail to satisfy the constraints, a warning of clustering failure is issued and different cluster centers are needed to be selected randomly to reinitialize the process.\n\n#### Constrained Seed k-means\n\nConstrained Seed k-means[16] was proposed by Basu et al. This algorithm is different from Constrained k-means, which uses Must Link and Connect Link constraints as supervision information, but directly uses labeled data as supervision information. Since there are some labeled data, the cluster center can be calculated directly on the labeled dataset, which effectively alleviates the cluster instability caused by the randomness of the initial cluster centers selection. The number of classes of the labeled dataset can be used as the number of clusters in the clustering algorithm, which avoids the bad clustering results caused by unreasonable k value selection. Unlike k-means algorithm, in which all samples are judged to which cluster they should belong in the iterative process, Constrained Seed k-means algorithm only updates the cluster labels of unlabeled data. For labeled samples, their cluster labels are fixed with their real labels and not change as the change of cluster centers. The clusterer is more reliable when using labeled data to participate in the clustering process, which alleviates the blindness of unsupervised clustering and effectively reduces the large gap between the clustering results and the real labels of the samples. It also alleviates the instability caused by randomness.\n\n## Deep Semi-supervised Learning\n\nLAMDA-SSL contains 18 deep model-based semi-supervised learning algorithms (as shown in Figure 10): the algorithms used for classification tasks include the consistency regularization method Ladder Network, Π Model, Temporal Ensembling, Mean Teacher, VAT, UDA, Pseudo label-based methods Pseudo Label, S4L, hybrid methods ICT, MixMatch, ReMixMatch, FixMatch, FlexMatch, generative methods ImprovedGAN, SSVAE, deep graph based methods SDNE, GCN; the algorithms for regression tasks include consistency regularization method Π Model Reg, Mean Teacher Reg and hybrid method ICT Reg.\n\n### Consistency Regularization\n\nDeep learning methods guide the direction of model training by setting the loss function with gradient descent. Consistency regularization methods are based on the assumption of consistency, which assumes if a certain degree of disturbance is added to samples, the prediction results should be consistent with the previous. These methods often introduces a consistency regularization term into the loss function which enables unlabeled samples to participate in the model training process to improve the robustness of the model to noise\n\n#### Ladder Network\n\nLadderNetwork[17] was proposed by Rasmus et al. This method adopts an autoencoder structure, in which the outputs of the last layer of the encoder are soft labels. The LadderNetwork adopts two encoding methods, the first is the classical encoder without noise, that is, and the second is the encoder with noise, which add noise to inputs of each layer of the classical encoder.   LadderNetwork firstly performs noise encoding and non-noise encoding on the samples respectively and obtains the noisy representation and the non-noisy representation of each layer. Then the decoder is used to decode the noisy encoding result, and the noisy decoding representations of each layer are obtained. Finally, mean square error(MSE) loss is used to calculate the inconsistency between the non-noisy encoded representation and the noisy decoded representation at each layer, including the original input data as the zeroth layer. The previously determined weights are used to determine the weights of inconsistency of each layer. Hierarchical inconsistencies are weighted as an unsupervised loss function, thereby improving the robustness of model. The consistency regularization of LadderNetwork uses the noisy encoded representation as a bridge to penalize the inconsistency between the non-noisy encoded representation and the noisy decoded representation. On the one hand, an auto-encoder can be obtained to make the representations of the encoder and the decoder consistent at all levels. On the other hand, the hidden layer representations keep consistent regardless weather noise is added, which makes the model can against disturbances.\n\n<div align=center>\n\n<img width=\"300px\" height=\"300px\"  src=\"./Imgs/LadderNetwork.png\" >\n\n<br>\n\nFigure 14[3]: LadderNetwork Algorithm\n\n</div>\n\n#### UDA\n\nUDA[18] was proposed by Xie et al. Unlike LadderNetwork, UDA only perturbs the input samples instead of all inputs of hidden layers. And UDA does not necessarily use Gaussian noise for perturbation, but may use various data augmentation methods. Compared with Gaussian noise, data augmentation used by UDA, such as image rotation or text replacement have a greater impact on the data, which can further improve the robustness of the model. UDA performs data augmentation on the unlabeled samples and then compares the prediction results before and after the augmentation. The mean square error loss is used to calculate the consistency regularization term as the unsupervised loss.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/UDA.png\" >\n\n<br>\n\nFigure 15[3]: UDA Algorithm\n\n</div>\n\n#### Pi Model\n\nPi Model[19] was proposed by Laine et al. Unlike UDA, which augments the unlabeled data once and compares the prediction results before and after the augmentation and calculates the consistency regular term. Pi Model augments the data twice randomly and respectively uses the results of the two augmentations as inputs of the neural network model to get prediction results. The inconsistency of the prediction results are used as the unsupervised loss. Due to the randomness of the augmentation process, the two augmentations of this method will obtain two pieces of samples that are semantically similar but may have slightly difference in features. Through the consistency regularization, the model can produce similar prediction results for different augmentations with a certain range.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/PiModel.png\" >\n\n<br>\n\nFigure 16[3]: Π Model Algorithm\n\n</div>\n\n#### Temporal Ensembling\n\nTemporal Ensembling[19] are proposed by Laine et al. This method makes some improvements to Pi Model. In Pi Model, for each unlabeled sample, Pi Model needs to perform two augmentations and calculate the inconsistency of their prediction results, which brings a large consumption of computing power. Temporal Ensembling method changes one of the pseudo-label predictions to exponential moving average(EMA) of historical pseudo-labels, which is a weighted average of historical results. The weights of pseudo-labels decay exponentially in each round. This ensemble method effectively preserves the historical pseudo-labels information and get unsupervised loss by calculating the consistency between the current pseudo-label and the ensemble of historical pseudo-labels. Tthe historical ensemble is updated at the end of each epoch. EMA guarantees the robustness of the model. It avoids the model being overly affected by a single round of prediction and slows down the model’s forgetting speed of historical information. Temporal Ensembling only needs to augment and predict once for each sample in each round. Historical information can be maintained with only one weighted average calculation, which greatly reduces computing power consumption compared to Pi Model.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/TemporalEnsembling.png\" >\n\n<br>\n\nFigure 17[3]: Temporal Ensembling Algorithm\n\n</div>\n\n#### Mean Teacher\n\nMean Teacher[20] was proposed by Tarvainen et al. This method relies on the idea of ​​knowledge distillation, where the prediction results of the teacher model are used as pseudo-labels to train the student model to ensure the consistency of the prediction results of the teacher model and the student model, thereby distilling knowledge from a more complex model to a simpler one. The purpose of the classical knowledge distillation method is to simplify the model, but the purpose of Mean Teacher is to make unlabeled data participate in the learning process and improve the robustness of the model. Therefore, the teacher model is not a complex model, but performs exponential moving average on the parameters based on the student model, which reduces the computational cost compared to the classical knowledge distillation method. Temporal Ensembling method performs EMA on the prediction results of each round, but the overall historical information only can be updated at the end of each round. Especially for large data sets, the historical information cannot be updated in time. Different from Temporal Ensembling, Mean Teacher uses EMA for model parameters and updates the historical information of model parameters in time after each batch of training. Mean Teacher is more flexible and general because it effectively solves the problem of untimely update and utilization of historical information.\n\n<div align=center>\n\n<img width=\"300px\" height=\"300px\" src=\"./Imgs/MeanTeacher.png\" >\n\n<br>\n\nFigure 18[3]: MeanTeacher Algorithm\n\n</div>\n\n#### VAT\n\nVAT[21] was proposed by Miyato et al. Different from the methods of adding random noise to the data, the idea of ​​VAT is to add adversarial noise to the data, so that the worst performance of the model can be better when the data is affected by noise within a certain range, which corresponds to the zero-sum game in game theory and Min-Max problem in optimization. For classical supervised adversarial algorithms, the cross-entropy loss between the real labels and prediction results is usually used as the goal of adversarial optimization. The noise that maximizes the loss for the current model and data is obtained through the inner layer optimization. The outer layer optimization is used to obtain the model parameters which minimizes the loss. Inner and outer optimization are alternately performed, so that the model can not perform too bad in the worst case when dealing with data noise. The outer optimization is to optimize the model parameters, which is often carried out by gradient descent, while the inner optimization is optimized for data noise, in which there is no closed-form solution. The inner optimization is not suitable to use gradient optimization and it is necessary to approximate the optimal noise. Linear approximation is often used in classical supervised adversarial algorithms. It firstly predicts on the clear data and calculate the value of the loss function. Then it carries out the gradient backward to obtain the gradient. Finally it takes the product of the normalized gradient and the noise upper bound as the adversarial noise. Different from classical supervised adversarial algorithms, VAT needs to solve the problem in semi-supervised scenarios where loss of unlabeled data cannot be calculated supervisely and then adversarial noise cannot be obtained by gradient. In order to solve this problem, VAT adopts the consistency strategy. It changes the supervised loss to the consistency loss which uses the model to predict on the clear data and the noisy data respectively to obtain the clear pseudo-labels and the noisy pseudo-labels. Then it calculates the consistency between them. In VAT, linear approximation cannot be used for the inner optimization on unlabeled data because it is necessary to calculate the classification loss with real labels and VAT replaces real labels with pseudo-labels resulting in the gradient returned is always 0. So VAT uses second-order Taylor approximation instead of linear approximation, so the problem of computing against noise is transformed into the problem of computing the principal eigenvectors of the Hessian matrix of the loss function for noise. When the noise of data is d-dimensional, the time complexity of calculating the eigenvector of Hessian matrix is O\\left(d^3\\right). In order to solve the problem of excessive computational complexity, VAT adopts power iteration method to solve the approximate matrix eigenvectors, which randomly samples the approximated eigenvectors and continuously multiply the matrix and the current approximated eigenvectors to obtain new ones. Continuously performing this process can consume less time. In order to further avoid the direct calculation of the Hessian matrix, VAT adopts the Finite Difference method to approximate the product of the matrix and the approximate eigenvector. Compared with other methods based on consistency regularity, the use of anti-noise in the VAT method can further improve the robustness of the model than random noise and avoid excessive interference of randomness on the experimental results because the performance in the worst case has a better theoretical basis. VAT avoids excessive additional computational overhead through approximation methods when calculating adversarial noise and solves the dilemma that supervised adversarial algorithms cannot be directly applied to unlabeled data.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/VAT.png\" >\n\n<br>\n\nFigure 19[3]: VAT Algorithm\n\n</div>\n\n### Pseudo Labeling\n\nMethods based on pseudo-labeling make unlabeled data affect the learning process by assigning pseudo-labels to unlabeled data. Since the confidence levels of the model for different samples are different, the method based on pseudo-labels usually takes samples with higher confidence and their pseudo-labels to participate in the training process.\n\n#### Pseudo Label\n\nPseudo Label[22] was proposed by Lee et al. This method is the most basic pseudo-labeling method. Its loss function includes two items supervised loss and unsupervised loss, both of which are cross-entropy loss functions. For unlabeled data, the Pseudo Label performs softmax operation on the output of the neural network to obtain the confidence of classification. Pseudo Label takes the category with the highest confidence as the pseudo-label of the sample and uses the pseudo-label to calculate the cross-entropy loss. In addition, in each round, not all unlabeled samples will participate in the training process. They participate in the training process only when the confidence of them in this round are greater than the set threshold. Pseudo Label also sets hyperparameters to control the proportion of unsupervised loss and supervised loss and adopts a warmup mechanism. At the beginning of training, the proportion of unsupervised loss is low and as the training goes on, the proportion is increasing.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/PseudoLabel.png\" >\n\n<br>\n\nFigure 20[3]: Pseudo Label Algorithm\n\n</div>\n\n#### S4L\n\nS4L[23] was proposed by Beyer et al. This method uses self-supervised technology. The basic idea is that unlabeled data cannot directly participate in the training of classifiers, but self-supervision can be used to affect the representation layer, so that the model can learn better hidden layer representations. This method is mainly used for image data. One of 0^\\circle, 90^\\circle, 180^\\circle, and 270^\\circle is randomly selected as the degree to rotate the image, and the angle is used as a pseudo-label. A neural network model can be trained to classify angles. Although the final classification layer of the neural network is different from the target task, the learned hidden layer representation is helpful for learning the real task. For labeled data, S4L uses two labels, a pseudo label representing the degree of rotation and a real label for the target task. S4L uses two classification layers for labeled data, one of which is the degree classifier shared with unlabeled data, and the other is the true classifier for the target task, and both classification layers share the same hidden layer. Through the above methods, S4L enables the model to learn better representations while training the self-supervised classifier, thereby improving the classification effect of the model on the target task. Different from the pre-training and fine-tuning paradigms, S4L does not need to train the model in advance, but can process labeled data and unlabeled data at the same time to promote each other. Labeled data also participates in the self-supervised learning process of S4L. S4L can also be generalized to other types of data, and corresponding self-supervised training methods need to be adopted.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/S4L.png\" >\n\n<br>\n\nFigure 21[3]: S4L Algorithm\n\n</div>\n\n### Hybird Method\n\nThere are often no conflicts among different semi-supervised learning techniques. Many commonly used semi-supervised learning algorithms are not limited to using only one type of techniques, but combine techniques such as consistency and pseudo-annotation et al and use their own strengths to generate new hybrid methods. Hybrid methods can leverage the advantages of different techniques simultaneously to achieve better training results.\n\n#### ICT\n\nICT[24] was proposed by Verma et al. The full name of  ICT is Interpolation Consistency Training. The data and prediction results are linearly interpolated by Mixup [35] which is a data augmentation method. ICT introduces unlabeled data into the training process by using the consistency between the model's predictions on the interpolated samples and the interpolation of the model's predictions on the original data. Mixup generates a parameter which means mixing ratio from the Beta distribution, and linearly interpolates two samples using the ratio parameter to obtain the mixed sample. The loss function of ICT is divided into two parts: supervised loss and unsupervised loss. The supervised loss is calculated by the cross entropy function and the unsupervised loss is calculated by the interpolation consistency. For each batch of data, ICT firstly samples a mixing parameter according to the Beta distribution. Then ICT randomly scrambles the batch of samples, and mixes the scrambled batch data with the unscrambled batch data in proportion to the mixing parameter. The model predicts on the unscrambled batch data and the mixed batch data to get the unscrambled prediction results and the mixed prediction results. Finally ICT linearly interpolates the unscrambled prediction results and the scrambled prediction results with the same mixing parameters as the samples and takes the inconsistency as the unsupervised loss. For mixed unlabeled data, ICT makes the soft labels output by the model close to the mix of pseudo-labels and combines consistency technology with pseudo-label technology to make the model more robust.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/ICT.png\" >\n\n<br>\n\nFigure 22[3]: ICT Algorithm\n\n</div>\n\n#### MixMatch\n\nMixMatch[25] was proposed by Berthelot et al. This method also uses Mixup method, but unlike ICT which only mixes unlabeled data samples, MixMatch mixes both labeled data and unlabeled data. MixMatch firstly augments the unlabeled data multiple times and makes multiple predictions. By averaging and sharpening the results of multiple predictions, the pseudo-labels of the unlabeled data are obtained. Multiple augmentations make the pseudo-labels more reliable. Sharpening the pseudo-labels reduces the entropy of the label distribution, allowing the classification boundaries to pass through the low-density regions of the samples as much as possible. Then MixMatch combines and shuffles the labeled data set and the unlabeled data set to form a new mixed data set. The same amount of samples as the original labeled samples are taken out from the mixed data set to form a new labeled data set by Mixup and the remaining samples in the mixed data set forms a new labeled data set by Mixup too. Finally, MixMatch predicts on the new labeled data set and the new unlabeled data set respectively. It uses the prediction results of the new labeled data set to calculate the cross entropy as the supervised loss and uses the new unlabeled data set to calculate the mean square error as the unsupervised loss. The two terms are combined by a weight parameter. Different from other methods which calculate the loss of labeled data and unlabeled data separately, MixMatch combines, shuffles, and re-partitions labeled data set and unlabeled data set, which reduces the risk of model performance degradation due to wrong pseudo-labels. MixMatch is helpful to use real labels to assist the training of unlabeled data and guide the correct training direction of unlabeled consistency which not only ensures the original robustness of the consistency regularization, but also prevents the model from excessive target deviation due to the inconsistency between pseudo-labels and real labels.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/MixMatch.png\" >\n\n<br>\n\nFigure 23[3]: MixMatch Algorithm\n\n</div>\n\n#### ReMixMatch\n\nReMixMatch[26] was proposed by Berthelot et al. ReMixMatch is an improved version of MixMatch. It introduces two techniques: distribution alignment and augmented anchoring. The purpose of distribution alignment is to make the pseudo-labels predicted by the model for unlabeled data have the same marginal probability distribution as the real labels of labeled data. In deep learning, the label distribution of the labeled data and the pseudo-label distribution of the unlabeled data are different because the model's predictions are often biased towards the categories which have more samples and the use of a sharpening operation reduces the entropy of the label distribution to force the classification boundaries to pass through low-density regions as much as possible. There is an unfair phenomenon among categories in the pseudo-labels of data and the distribution alignment technology effectively alleviates this problem. The distribution alignment technology calculates the true label distribution of the labeled data. In each batch of training, the soft label distribution is calculated. For the soft label of a sample, ReMixMatch multiplys it by the ratio of the real label distribution and the current batch soft label distribution to obtain the aligned soft label and sharpens the aligned soft label to obtain the pseudo label of the sample. Augmented anchoring is to adapt the model to stronger data augmentation. For supervised learning methods, applying stronger data augmentation to the data can further improve the generalization ability of the model because no matter whether strong or weak augmentation is applied to the sample, its label will not change. In semi-supervised learning, pseudo-labels are often obtained from the prediction results on unlabeled data by the model. The pseudo-labels will change with the form of data augmentation. If a strong augmentation is applied to the samples, it is easy to make the pseudo-labels deviate too much from the real labels. It makes MixMatch incompatible with strong data augmentation methods. By introducing augmented anchoring technology, ReMixMatch performs weak data augmentation on unlabeled samples. The model predicts for weakly augmented unlabeled samples to get pseudo-labels and fixes them as \"anchors\", so that no matter what kind of data augmentation is performed on the unlabeled data in the future, the pseudo-labels will not change. ReMixMatch performs one weak data augmentation and multiple strong data augmentation on the unlabeled data, and uses the model's prediction results for the weakly augmented data as pseudo-labels after alignment and sharpening. The augmented dataset composes a larger unlabeled dataset. ReMixMatch uses the same strategy as MixMatch to combine, shuffle and re-partition the labeled and unlabeled datasets. In addition, the loss function of ReMixMatch is quite different from that of MixMatch. The supervised loss and unsupervised loss of ReMixMatch are both calculated by cross entropy and different from MixMatch's loss function which only includes supervised loss and unsupervised loss, ReMixMatch adds two items. Although Mixup makes the model have better generalization performance, only using the data after Mixup may ignore some information of the data set before Mixup, so ReMixMatch takes one out of multiple augmented data sets before Mixup and uses it to calculate the unsupervised loss of pre-Mixup dataset as the third term of the loss function. ReMixMatch also draws on the self-supervised strategy of S4L. Samples from the augmented dataset are randomly rotated and their rotation angles are predicted to promote the learning of the hidden layer of the model. The cross-entropy loss for classifying the rotation angle is used as the fourth term of the loss function. ReMixMatch integrates multiple techniques in a more complex framework that not only combines the strengths of each method, but is more general because of its comprehensiveness.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/ReMixMatch.png\" >\n\n<br>\n\nFigure 24[3]: ReMixMatch Algorithm\n\n</div>\n\n#### FixMatch\n\nFixMatch[27] was proposed by Sohn et al. FixMatch also uses strong data augmentation and weak data augmentation. Unlike ReMixMatch, which uses augmented anchoring to fix pseudo-labels of unlabeled data by weak data augmentation. FixMatch pays more attention to the consistency of prediction results between weakly augmented data and strong augmented data. Similar to ReMixMatch, FixMatch also obtains hard pseudo-labels according to the prediction results of the model for weakly augmented data. After that, FixMatch augments the unlabeled data strongly to obtain the prediction results. FixMatch only uses the unlabeled data with which the model is confident for training using a threshold parameter. Only when the confidence is greater than the threshold parameter, the data will participate in the training process. FixMatch calculates the cross-entropy using the pseudo-labels obtained by the model for weakly augmented samples and the prediction results obtained by the model for strong augmented samples as unsupervised loss. Fixmatch combines the unsupervised loss and the supervised loss by a weight parameter as the final loss.\n\n<div align=center>\n\n<img width=\"500px\"  src=\"./Imgs/FixMatch.png\" >\n\n<br>\n\nFigure 25[3]: FixMatch Algorithm\n\n</div>\n\n#### FlexMatch\n\nFlexMatch[28] was proposed by Zhang et al. FlexMatch is an improvement version of FixMatch and focuses on solving the unfair phenomenon between categories in semi-supervised learning. FixMatch selects unlabeled samples with high confidence and their pseudo-labels according to fixed threshold to participate in the training process. But sometimes although the original The dataset is class-balanced, due to the different learning difficulty of each class, using a fixed threshold for selecting will cause some classes which are difficult to learn to be less used in the training process than which are easy to learn. The model has lower confidence in the samples whose classes are more difficult to learn, which further exacerbates the class imbalance of the unlabeled data participating in the training. This unfairness forms a vicious circle and causes Matthew effect in Fixmatch. This unfairness forms a vicious circle, resulting in the Matthew effect, which causes the model to learn less and less well for the categories which are hard to learn. Therefore, different selecting criteria should be used for different categories to alleviate the class imbalance caused by different learning difficulties. FlexMatch uses dynamic threshold on the basis of FixMatch. It sets a lower confidence threshold for the classes that are more difficult to learn. One of the most basic methods is to set a validation dataset thresholds according to the accuracy rates on the validation dataset. However, since the labeled training data is relatively scarce, and the verification accuracy of the model is continuously updated during the training process, it will cause a large computational. Therefore, FlexMatch adopts the method of approximately evaluating the accuracy. Flexmatch firstly counts the number of times for each class that the class is consider as the pseudo-label and the confidence is greater than the threshold respectively for each batch of unlabeled data. After that, the statistics of different categories are divided by their maximum value and normalized as the evaluation of the classification difficulty. Finally, Flexmatch multiplys the fixed threshold by the classification difficulty metric of each category to get the dynamic thresholds for each category in current batch of unlabeled data. FlexMatch better alleviates the problem of class imbalance caused by different learning difficulties after unlabeled data is selected according to the confidence and does not cause excessive extra computing time and storage.\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/FlexMatch.png\" >\n\n<br>\n\nFigure 26[28]: FlexMatch Algorithm\n\n</div>\n\n### Deep Generative Model\n\nGenerative methods use real data to model a data distribution, and this distribution can be used to generate new data. Unlike classical generative models, deep generative models generate data based on deep neural networks. Generative Adversarial Network(GAN) and Variational Autoencoder(VAE) are the most commonly used generative models.\n\n#### ImprovedGAN\n\nGenerative Adversarial Network is divided into two parts: the generator and the discriminator, where the generator assumes that the data can be generated by low-dimensional latent variables generated from a specific distribution and is used to generate simulated data by randomly sampling from the latent variable distribution. The generator is a classifier, which is used to distinguish whether the input sample is real data or simulated data generated by the generator. The generator is optimized to make the generated samples as close as possible to the real samples to deceive the discriminator and the discriminator is optimized to distinguish real data or simulated data as accurately as possible to avoid being deceived by the generator. The two are trained together in an adversarial manner, so as to achieve the purpose of obtaining a better generator and discriminator at the same time.\n\nImprovedGAN[29] was proposed by Salimans et al. Classical GAN model can be trained only with unlabeled data, and its discriminator only needs to judge whether the sample is a real sample or a generated sample. ImprovedGAN adds the use of labeled data, requiring the discriminator not only to distinguish the authenticity of the samples, but also to complete the classification of the samples. So the discriminator is changed to a k+1 class classifier, where k is the number of classes in the original dataset. Both data generation and classification can be achieved through the alternate training of the generator and the discriminator.\n\n<div align=center>\n\n<img width=\"300px\"  src=\"./Imgs/ImprovedGAN.png\" >\n\n<br>\n\nFigure 27[3]: ImprovedGAN Algorithm\n\n</div>\n\n#### SSVAE\n\nVariational Autoencoder integrates the deep autoencoder into the generative model. It also assumes that there are low-dimensional latent variables generated from a specific distribution. The latent variable is used as the representation vector of the original feature, and establish the mapping of latent variables to the original features as the decoder through the deep neural network. Since the posterior probability of meta-features to latent variables cannot be directly obtained, it also needs to be approximated by a neural network. As an encoder, the learning goal is to maximize the marginal probability of the original sample. VAT can learn a distribution that approximates the true posterior distribution and using it as an encoder can get a reasonable sample representation because when the approximate posterior distribution is equal to the true posterior distribution, the marginal probability can reach its upper bound.\n\nSSVAE[30] was proposed by Kingma et al. Classical VAE model can be trained only with unlabeled data, and its goal is to complete the learning of data representation through the encoder, and realize data generation through the decoder. SSVAE adds the application of labeled samples, and divides the encoder into two parts. The first part encodes the original data to obtain the probability distribution of the soft labels of the samples, and the second part uses the raw data and soft labels as input to obtain probability distributions of the hidden variables. The encoder of the classical VAE model only learns the representation of the data. The encoder of the SSVAE can firstly classify the samples and then can combine the sample information and the category information to learn the representation of the samples.\n\n<div align=center>\n\n<img width=\"300px\"   src=\"./Imgs/SSVAE.png\" >\n\n<br>\n\nFigure 28[3]: SSVAE Algorithm\n\n</div>\n\n### Deep Graph Based Method\n\nWhen the raw data is a graph, since the instances are not independent but connected by edges, the classical deep learning method cannot effectively utilize the structural information of the graph model, so it cannot be directly applied to the graph data. However, graph data is very common in practical applications and it is of great significance to study deep learning methods that can be used for graph data. At present, graph deep learning has achieved certain research results. The classical semi-supervised learning methods ignores the structural information of the graph, so the effect of directly applying them to graph-structured data is not ideal. In reality, graph data tasks are often semi-supervised, because the nodes to be predicted and the training nodes are on the same graph. There are both labeled data and unlabeled data in the graph.\n\n#### SDNE\n\nSDNE[31] was proposed by Wang et al. SDNE is a deep graph based semi-supervised learning method that can learn the embedding vector of nodes in the graph when there is no feature representation for the nodes in the graph and only graph structure information. This method adopts an autoencoder structure, takes the corresponding row of the node in the adjacency matrix as the adjacency vector of the node and inputs the adjacency vector of the node as the feature of the node into the self-encoder. SDNE obtains the embedded representation of the node through the encoder and restores the adjacency vector through the decoder. The loss function of SDNE mainly includes three items. The first item penalizes the inconsistency between the input and output of the autoencoder. In addition, unlike the classical autoencoder, the input of SDNE is an adjacency vector. Due to the sparseness of the adjacency matrix, there are a large number of zero values ​​in the input features. SDNE points out that more attention should be paid to the restoration of non-zero values, so zero and non-zero values ​​are given different weights. The second item is the Laplacian regularization which punishes the inconsistency of the hidden layer representation between adjacent nodes based on the graph structure information. The adjacency matrix is ​​used as the weight to obtain the Laplace regularization term. The third term is the L2 regularization, which penalizes the parameter complexity of the self-encoder to avoid overfitting. In SDNE, the first term of the loss function pays more attention to the characteristics of the node itself, while the second term pays more attention to the information between adjacent nodes which effectively solves the problem that the classical semi-supervised learning algorithm cannot effectively utilize the structural information of graphs.\n\n<div align=center>\n\n<img width=\"300px\" height='300px' src=\"./Imgs/SDNE.png\" >\n\n<br>\n\nFigure 29[3]: SDNE Algorithm\n\n</div>\n\n#### GCN\n\nGCN[32] was proposed by Kipf et al. Unlike SDNE, which uses the adjacency vector of the node as the node feature to learn the embedding representation, GCN is more suitable for the situation that the node itself has features. In GCN, both the feature information and graph structure information of the node itself are available, which significantly improves the performance of the model. In graph deep learning, graph neural network(GNN)[36] is the most commonly used class of methods. These methods usually take graphs with node features as input and can learn the deep representation of nodes to complete the learning assignment. The classical GNN method is divided into two steps: the first step is aggregation in which the information of the adjacent nodes are aggregated through the graph structure; the second step is update in which the nodes' representations are updated with their own representations and the information of their neighbors. By repeating these two steps, the deep representations of each node can be obtained. Due to the propagation effect of the aggregation operation, the deep representation of the node not only contains the information of the node itself, but also contains the information of the graph structure. The classical aggregation operation is linear aggregation which takes the linear combination of the representations of the neighbor nodes as the neighbor representation of the node. The classical update operation is to use the perceptron model to obtain new node representations from the nodes' own representations and their neighbor representations. The classical GNN model has some limitations. For examples, the aggregation method which linearly combines the representations of neighbor nodes makes nodes with larger numbers of degree have more influence while nodes with smaller numbers of degree have less influence on the entire training process. The GCN method directly adds the normalized neighbor representation to its own representation for each node and uses the result as the input of the perceptron to get a new representation. For each node, the normalization process divides the representation of its neighbor nodes and itself by the normalization factor, where the normalization factor of its neighbor nodes is the geometric mean of the degree of itself and its neighbor nodes while the normalization factor of itself is its own degree. GCN has excellent performance on graph structure tasks and its update process avoids the learning of linear combination weights of neighboring nodes so it has fewer parameters and higher efficiency.\n\n<div align=center>\n\n<img width=\"600px\"  src=\"./Imgs/GCN.png\" >\n\n<br>\n\nFigure 30[32]: GAT Algorithm\n\n</div>\n\n#### GAT\n\nGAT[33] is also applicable to the case where the node itself has features. Unlike the graph convolution operation of GCN, GAT introduces the  attention mechanism. In each iteration, the attention weight of each node is calculated according to the representations of itself and its neighboring nodes and its representation is updated with the weight.\n\n<div align=center>\n\n<img width=\"600px\"  src=\"./Imgs/GAT.png\" >\n\n<br>\n\nFigure 31[34]: GAT Algorithm\n\n</div>\n\n# API\n\n## LAMDA_SSL.Algorithm\n\n### LAMDA_SSL.Algorithm.Classifiacation\n\n#### LAMDA_SSL.Algorithm.Classifiacation.Assemble\n\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.Assemble.Assemble(base_model=SVC(probability=True),T=100,alpha=1,beta=0.9)\n> - Parameter:\n>> - base_model: A base learner for ensemble learning.\n>> - T: the number of base learners. It is also the number of iterations.\n>> - alpha: the weight of each sample when the sampling distribution is updated.\n>> - Beta: used to initialize the sampling distribution of labeled data and unlabeled data.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.Co_Training\n\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.Co_Training.Co_Training(base_estimator, base_estimator_2=None, p=5, n=5, k=30, s=75)\n> - Parameter:\n>> - base_estimator: the first learner for co-training.\n>> - base_estimator_2: the second learner for co-training.\n>> - p: In each round, each base learner selects at most p positive samples to assign pseudo-labels.\n>> - n: In each round, each base learner selects at most n negative samples to assign pseudo-labels.\n>> - k: iteration rounds.\n>> - s: the size of the buffer pool in each iteration.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.FixMatch\n\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.FixMatch.FixMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 parallel=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=5e-4\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 threshold=0.95,\n                 lambda_u=1.0,\n                 mu=1.0,\n                 ema_decay=0.999,\n                 T=0.5)\n> - Parameter:\n>> - threshold: The confidence threshold for choosing samples.\n>> - lambda_u: The weight of unsupervised loss.\n>> - T: Sharpening temperature.\n>> - num_classes: The number of classes for the classification task.\n>> - thresh_warmup: Whether to use threshold warm-up mechanism.\n>> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n>> - use_DA: Whether to perform distribution alignment for soft labels.\n>> - p_target: p(y) based on the labeled examples seen during training.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.FlexMatch\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.FlexMatch.FlexMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 threshold=None,\n                 lambda_u=None,\n                 mu=None,\n                 ema_decay=None,\n                 T=None,\n                 num_classes=10,\n                 thresh_warmup=None,\n                 use_hard_labels=False,\n                 use_DA=False,\n                 p_target=None\n                 )\n> - Parameter:\n>> - threshold: The confidence threshold for choosing samples.\n>> - lambda_u: The weight of unsupervised loss.\n>> - T: Sharpening temperature.\n>> - num_classes: The number of classes for the classification task.\n>> - thresh_warmup: Whether to use threshold warm-up mechanism.\n>> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n>> - use_DA: Whether to perform distribution alignment for soft labels.\n>> - p_target: p(y) based on the labeled examples seen during training\n\n#### LAMDA_SSL.Algorithm.Classifiacation.GCN\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.GCN.GCN(\n                 dim_in=1433,\n                 num_classes=7,\n                 dim_hidden=16,\n                 normalize=True,\n                 epoch=1,\n                 eval_epoch=None,\n                 network=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 parallel=None,\n                 file=None,\n                 device='cpu',\n                 evaluation=None\n                 )\n> - Parameter:\n>> - dim_in: Node feature dimension.\n>> - dim_hidden: the dimension of hidden layers.\n>> - num_classes: Number of classes.\n>> - normalize: Whether to use symmetric normalization.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.GAT\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.GAT.GAT(\n                 dim_in=1433,\n                 dim_hidden=16,\n                 dropout=0,\n                 heads=8,\n                 epoch=1,\n                 eval_epoch=None,\n                 network=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 parallel=None,\n                 file=None,\n                 device='cpu',\n                 evaluation=None\n                 )\n> - Parameter:\n>> - dim_in: Node feature dimension.\n>> - dim_hidden: the dimension of hidden layers.\n>> - num_classes: Number of classes.\n>> - dropout: The dropout rate.\n>> - heads: The number of heads.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.ICT\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.ICT.ICT(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmup=None,\n                 lambda_u=None,\n                 alpha=None)\n> - Parameter:\n>> - warmup: Warm up ratio for unsupervised loss.\n>> - lambda_u: The weight of unsupervised loss.\n>> - alpha: the parameter of Beta distribution in Mixup.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.ImprovedGAN\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.ImprovedGAN.ImprovedGAN(\n                 train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 epoch=1,\n                 network=None,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=0,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None,\n                 dim_in=(28,28),\n                 num_class=10,\n                 dim_z=500,\n                 hidden_G=[500,500],\n                 hidden_D=[1000,500,250,250,250],\n                 noise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5],\n                 activations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus()],\n                 activations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 lambda_u=1.0,\n                 num_labeled=None)\n> - Parameter:\n>> - dim_in: The dimension of a single instance.\n>> - num_classes: The number of classes.\n>> - dim_z: The dimension of the latent variables used to generate the data.\n>> - hidden_G: The hidden layer dimension of the neural network as the generator. If there are multiple hidden layers, it is represented by a list.\n>> - hidden_D: The hidden layer dimension of the neural network as the discriminator. If there are multiple hidden layers, it is represented by a list.。\n>> - noise_level: The noise level of each layer of the discriminator.\n>> - activations_G: The activation function of each layer of the generator.\n>> - activations_D: The activation function of each layer of the discriminator.\n>> - lambda_u: The weight of unsupervised loss.\n>> - num_labeled: The number of labeled samples.\n\n#### LAMDA_SSL.Algorithm.Classifiacation.LabelPropagation\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.LabelPropagation.LabelPropagation(kernel=\"rbf\",\n        gamma=20,\n        n_neighbors=7,\n        max_iter=30,\n        tol=1e-3,\n        n_jobs=None,\n    )\n> - Parameter:\n>> - kernel: The kernel function which can be inputted as a string 'rbf' or 'knn' or as a callable function.\n>> - gamma: The gamma value when the kernel function is rbf kernel.\n>> - n_neighbors: The n value when the kernel function is n_neighbors kernel.\n>> - max_iter: The maximum number of iterations.\n>> - tol: Convergence tolerance.\n>> - n_jobs: The number of parallel jobs.\n\n#### LAMDA_SSL.Algorithm.Classification.LabelSpreading\n> CLASS LAMDA_SSL.Algorithm.Classification.LabelSpreading.LabelSpreading(\n        kernel=\"rbf\",\n        gamma=10,\n        n_neighbors=7,\n        alpha=0.2,\n        max_iter=30,\n        tol=1e-3,\n        n_jobs=None)\n> - Parameter:\n>> - kernel: 'rbf'、'knn' or callable. Specifies the kernel type to be used in the algorithm.\n>> - gamma: The gamma value when the kernel function is rbf kernel.\n>> - n_neighbors: The n value when the kernel function is n_neighbors kernel.\n>> - alpha: The proportion of labels updates in each iteration.\n>> - max_iter: The maximum number of iterations.\n>> - tol: Convergence tolerance.\n>> - n_jobs: The number of parallel jobs.\n\n#### LAMDA_SSL.Algorithm.Classification.LadderNetwork\n> CLASS LAMDA_SSL.Algorithm.Classification.LadderNetwork.LadderNetwork(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 epoch=1,\n                 network=None,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None,\n                 dim_in=(28,28),\n                 num_classes=10,\n                 noise_std=0.2,\n                 lambda_u=[0.1, 0.1, 0.1, 0.1, 0.1, 10., 1000.],\n                 encoder_sizes=[1000, 500, 250, 250, 250],\n                 encoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()]\n                 )\n> - Parameter:\n>> - dim_in: The dimension of a single instance.\n>> - num_classes: The number of classes.\n>> - noise_std: The noise level of each layer of the discriminator.\n>> - lambda_u: The proportion of consistency loss of each layer in LadderNetwork.\n>> - encoder_sizes: The dimension of each layer of the encoder.\n>> - encoder_activations: The activation function of each layer of the encoder.\n\n#### LAMDA_SSL.Algorithm.Classification.LapSVM\n> CLASS LAMDA_SSL.Algorithm.Classification.LapSVM.LapSVM(\ndistance_function = rbf_kernel,\n           gamma_d=0.01,\n           neighbor_mode =None,\n           n_neighbor= 5,\n           kernel_function= rbf_kernel,\n           gamma_k=0.01,\n           gamma_A= 0.03125,\n           gamma_I= 0)\n> - Parameter:\n>> - distance_function: The distance function for building the graph. This Pamater is valid when neighbor_mode is None.\n>> - gamma_d: Kernel parameters related to distance_function.\n>> - neighbor_mode: The edge weight after constructing the graph model by k-nearest neighbors. There are two options 'connectivity' and 'distance', 'connectivity' returns a 0-1 matrix, and 'distance' returns a distance matrix.\n>> - n_neighbor: k value of k-nearest neighbors.\n>> - kernel_function: The kernel function corresponding to SVM.\n>> - gamma_k: The gamma parameter corresponding to kernel_function.\n>> - gamma_A: Penalty weight for function complexity.\n>> - gamma_I: Penalty weight for smoothness of data distribution.\n\n#### LAMDA_SSL.Algorithm.Classification.MeanTeacher\n> CLASS LAMDA_SSL.Algorithm.Classification.MeanTeacher.MeanTeacher(\ntrain_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 ema_decay=None,\n                 warmup=None,\n                 lambda_u=None)\n> - Parameter:\n>> - ema_decay: Update weights for the exponential moving average.\n>> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n>> - lambda_u: The weight of unsupervised loss.\n\n#### LAMDA_SSL.Algorithm.Classification.MixMatch.MixMatch\n> CLASS LAMDA_SSL.Algorithm.Classification.MixMatch.MixMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 warmup=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 mu=None,\n                 ema_decay=None,\n                 device='cpu',\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 T=None,\n                 num_classes=10,\n                 alpha=None\n                 )\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - T: Sharpening temperature for soft labels.\n>> - num_classes: The number of classes.\n>> - alpha: The parameter of the beta distribution in Mixup.\n\n#### LAMDA_SSL.Algorithm.Classification.PiModel\n> CLASS LAMDA_SSL.Algorithm.Classification.PiModel.PiModel(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 ema_decay=None,\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 warmup=0.4,\n                 lambda_u=None,\n                 )\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n\n#### LAMDA_SSL.Algorithm.Classification.PseudoLabel\n> CLASS LAMDA_SSL.Algorithm.Classification.PseudoLabel.PseudoLabel(self,train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 warmup=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 ema_decay=None,\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 threshold=0.95\n                 )\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - threshold: Confidence threshold for selecting samples.\n\n#### LAMDA_SSL.Algorithm.Classification.ReMixmatch\n> CLASS LAMDA_SSL.Algorithm.Classification.ReMixmatch.ReMixmatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 warmup=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 mu=None,\n                 ema_decay=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 T=None,\n                 num_classes=10,\n                 alpha=None,\n                 p_target=None,\n                 lambda_s=None,\n                 lambda_rot=None,\n                 rotate_v_list=None\n                 )\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - T: Sharpening temperature for soft labels.\n>> - num_classes: The number of classes.\n>> - alpha: The parameter of the beta distribution in Mixup.\n>> - p_target: The target distribution of labeled data.\n>> - lambda_s: The weight for unsupervised loss computed based on pre-mixup data.\n>> - lambda_rot: The weight of rotation angle classification loss.\n>> - rotate_v_list: A list of rotation angles.\n\n#### LAMDA_SSL.Algorithm.Classification.S4L\n> CLASS LAMDA_SSL.Algorithm.Classification.S4L.S4L(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 ema_decay=None,\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 num_classes=10,\n                 p_target=None,\n                 rotate_v_list=None,\n                 labeled_usp=True,\n                 all_rot=True)\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - num_classes: The number of classes.\n>> - p_target: The target distribution of labeled data.\n>> - rotate_v_list: A list of rotation angles.\n>> - labeled_usp: Whether to use labeled data when computing the unsupervised loss.\n>> - all_rot: Whether to rotate samples by all angles in rotate_v_list.\n\n#### LAMDA_SSL.Algorithm.Classification.SDNE\n> CLASS LAMDA_SSL.Algorithm.Classification.SDNE.SDNE(epoch=1,\n                 eval_epoch=None,\n                 optimizer=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 weight_decay=None,\n                 network=None,\n                 parallel=None,\n                 file=None,\n                 xeqs=True,\n                 dim_in=None,\n                 num_nodes=None,\n                 hidden_layers=[250, 250],\n                 alpha=1e-2,\n                 gamma=0.9,\n                 beta=5,\n                 base_estimator=None)\n> - Parameter:\n>> - xeqs: Whether to use the adjacency matrix as the feature matrix of the node.\n>> - dim_in: The dimension of node features. It is valid when xeqs is False.\n>> - num_nodes: The number of nodes.\n>> - hidden_layers: Encoder hidden layer dimension.\n>> - alpha: The weight of Laplacian regularization.\n>> - gamma: The weight of L2 regularation.\n>> - beta: The weight of the edges in the graph that are not 0 in the loss of consistency between the input and output of the autoencoder.\n>> - base_estimator: A supervised learner that classifies using the node features obtained by the encoder.\n\n<!-- #### LAMDA_SSL.Algorithm.Classification.Self_training\n> CLASS LAMDA_SSL.Algorithm.Classification.Self_Training.Self_training(base_estimator,\n                threshold=0.75,\n                criterion=\"threshold\",\n                k_best=10,\n                max_iter=10,\n                verbose=False)\n> - Parameter:\n>> - base_estimator: Self_training算法中使用的基监督学习器。\n>> - criterion: 有'threshold'和'k_best'两种形式，前者根据阈值选择样本，后者根据排名选择样本。\n>> - threshold: criterion为'threshold'时，自训练中选择样本使用的阈值。\n>> - k_best: criterion为'k_best'时，自训练中选择自信度前k的样本。\n>> - max_iter: 迭代次数上界。\n>> - verbose: 是否允许冗余输出。 -->\n\n#### LAMDA_SSL.Algorithm.Classification.SemiBoost\n> CLASS LAMDA_SSL.Algorithm.Classification.SemiBoost.SemiBoost(base_estimator =SVC(),\nsimilarity_kernel = 'rbf',\n                        n_neighbors=4, \n                        gamma=0.1, \n                        T = 300,\n                        sample_percent = 0.01,\n                        sigma_percentile = 90,\n                        n_jobs = 1\n                        )\n> - Parameter:\n>> - base_estimator: The base supervised learner used in the algorithm.\n>> - similarity_kernel: 'rbf'、'knn' or callable. Specifies the kernel type to be used in the algorithm.\n>> - n_neighbors: It is valid when the kernel function is 'knn', indicating the value of k in the k nearest neighbors.\n>> - n_jobs: It is valid when the kernel function is 'knn', indicating the number of parallel jobs.\n>> - gamma: It is valid when the kernel function is 'rbf', indicating the gamma value of the rbf kernel.\n>> - T: The maximum number of models in the ensemble and the number of iterations.\n>> - sample_percent: The number of samples sampled at each iteration as a proportion of the remaining unlabeled samples.\n>> - sigma_percentile: Scale parameter used in the 'rbf' kernel.\n\n#### LAMDA_SSL.Algorithm.Classification.SSGMM\n> CLASS LAMDA_SSL.Algorithm.Classification.SSGMM.SSGMM(num_classes, tolerance=1e-8, max_iterations=300)\n> - Parameter:\n>> - num_classes: The number of classes.\n>> - tolerance: Tolerance for iterative convergence.\n>> - max_iterations: The maximum number of iterations.\n\n#### LAMDA_SSL.Algorithm.Classification.SSVAE\n> CLASS LAMDA_SSL.Algorithm.lassification.SSVAE.SSVAE(\n                 alpha,\n                 dim_in,\n                 num_classes=10,\n                 dim_z=50,\n                 dim_hidden_de=[ 500,500],\n                 dim_hidden_en_y=[ 500,500], dim_hidden_en_z=[ 500,500],\n                 activations_de=[nn.Softplus(), nn.Softplus()],\n                 activations_en_y=[nn.Softplus(), nn.Softplus()],\n                 activations_en_z=[nn.Softplus(), nn.Softplus()],\n                 num_labeled=None,\n                 train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 epoch=1,\n                 network=None,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=0,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None)\n> - Parameter:\n>> - alpha: The weight of classification loss.\n>> - dim_in: The dimension of the input sample.\n>> - num_classes: The number of classes.\n>> - dim_z: The dimension of the hidden variable z.\n>> - dim_hidden_de: The hidden layer dimension of the decoder.\n>> - dim_hidden_en_y: The hidden layer dimension of the encoder for y.\n>> - dim_hidden_en_z: The hidden layer dimension of the encoder for z.\n>> - activations_de: The activation functions of the decoder.\n>> - activations_en_y: The activation functions of the encoder for y.\n>> - activations_en_z: The activation functions of the encoder for z.\n>> - num_labeled: The number of labeled samples.\n\n#### LAMDA_SSL.Algorithm.Classification.TemporalEnsembling\n> CLASS LAMDA_SSL.Algorithm.Classification.TemporalEnsembling.TemporalEnsembling(valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 mu=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 ema_decay=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 warmup=None,\n                 ema_weight=None,\n                 num_classes=None,\n                 num_samples=None\n                 )\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n>> - ema_weight: Update weight for exponential moving average pseudo labels。\n>> - num_classes: The number of classes.\n>> - num_samples: The number of samples.\n\n#### LAMDA_SSL.Algorithm.Classification.Tri_Training\n> CLASS LAMDA_SSL.Algorithm.Classification.Tri_Training.Tri_Training(base_estimator,base_estimator_2=None,base_estimator_3=None)\n> - Parameter:\n>> - base_estimator: The first base learner in TriTraining.\n>> - base_estimator_2: The second base learner in TriTraining.\n>> - base_estimator_3: The third base learner in TriTraining.\n\n#### LAMDA_SSL.Algorithm.Classification.TSVM\n> CLASS LAMDA_SSL.Algorithm.Classification.TSVM.TSVM(Cl=1.0,\n            Cu=0.001,\n            kernel=rbf_kernel,\n            degree=3,\n            gamma=\"scale\",\n            shrinking=True,\n            probability=False,\n            tol=1e-3,\n            cache_size=200,\n            class_weight=None,\n            verbose=False,\n            max_iter=-1,\n            decision_function_shape=\"ovr\",\n            break_ties=False,\n            random_state=None)\n> - Parameter:\n>> - Cl: The weight of labeled samples.\n>> - Cu: The weight of unlabeled samples.\n>> - kernel: 'rbf'、'knn' or callable. Specifies the kernel type to be used in the algorithm.\n>> - degree: The polynomial order corresponding to the 'poly' kernel.\n>> - gamma: The gamma parameter corresponding to the kernel. It is valid when kernel is 'rbf', 'poly' or 'sigmoid'.\n>> - coef0: The constant term of the kernel function. It is valid when kernel is 'poly' or 'sigmoid'.\n>> - shrinking: Whether to use the shrinking heuristic method.\n>> - probability: Weights for rotation angle classification loss.\n>> - tol: Tolerance to stop training, default is 1e-3.\n>> - cache_size: The cache size of the Kernel function.\n>> - class_weight: The weights of different classes.\n>> - verbose: Whether to allow redundant output.\n>> - max_iter: The maximum number of iterations. -1 for unlimited.\n>> - decision_function_shape: {'ovo', 'ovr'}, default='ovr'. Whether to return a one-vs-rest ('ovr') decision function of shape(n_samples, n_classes) as all other classifiers, or the original one-vs-one ('ovo') decision function of libsvm which has shape (n_samples, n_classes * (n_classes - 1) / 2). However, one-vs-one ('ovo') is always used as multi-class strategy. The parameter is ignored for binary classification.\n>> - break_ties: Whether to classify by calculating confidence in the event of a tie.\n>> - random_state: A random seed for data shuffling.\n\n#### LAMDA_SSL.Algorithm.Classification.UDA\n> CLASS LAMDA_SSL.Algorithm.Classification.UDA.UDA(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 evaluation=None,\n                 ema_decay=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 threshold=0.95,\n                 num_classes=None,\n                 tsa_schedule=None,\n                 T=0.4)\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - threshold: The confidence threshold for choosing samples.\n>> - num_classes: The number of classes.\n>> - tsa_schedule: Threshold adjustment strategy, optional 'linear', 'exp' or 'log'.\n>> - T: Sharpening temperature for soft labels.\n\n#### LAMDA_SSL.Algorithm.Classification.VAT\n> CLASS LAMDA_SSL.Algorithm.Classification.VAT.VAT(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 mu=None,\n                 ema_decay=None,\n                 device='cpu',\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 num_classes=None,\n                 tsa_schedule=None,\n                 eps=6,\n                 warmup=None,\n                 it_vat=1,\n                 xi=1e-6,\n                 lambda_entmin=0.06)\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - num_classes: The number of classes.\n>> - tsa_schedule: Threshold adjustment strategy, optional 'linear', 'exp' or 'log'.\n>> - eps: noise level.\n>> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n>> - xi:The scale parameter used when initializing the disturbance variable r, $r=\\xi d$. d is a random unit vector.\n>> - lambda_entmin: Entropy minimizes the weight of the loss.\n\n### LAMDA_SSL.Algorithm.Regression\n\n#### LAMDA_SSL.Algorithm.Regression.CoReg\n> CLASS LAMDA_SSL.Algorithm.Regression.CoReg.CoReg(k1=3, k2=3, p1=2, p2=5, max_iters=100, pool_size=100)\n> - Parameter:\n>> - k1: The k value for the k-nearest neighbors in the first base learner.\n>> - k2: The k value for the k-nearest neighbors in the second base learner.\n>> - p1: The order of the distance calculated in the first base learner.\n>> - p2: The order of the distance calculated in the second base learner.\n>> - max_iters: The maximum number of iterations.\n>> - pool_size: The size of the buffer pool.\n\n#### LAMDA_SSL.Algorithm.Regression.ICTReg\n> CLASS LAMDA_SSL.Algorithm.Regression.ICTReg.ICTReg(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmup=None,\n                 lambda_u=None,\n                 alpha=None,\n                 dim_in=None)\n> - Parameter:\n>> - warmup: Warm up ratio for unsupervised loss.\n>> - lambda_u: The weight of unsupervised loss.\n>> - alpha: the parameter of Beta distribution in Mixup.\n>> - dim_in: the dim of the instances.\n\n#### LAMDA_SSL.Algorithm.Regression.MeanTeacherReg\n> CLASS LAMDA_SSL.Algorithm.Regression.MeanTeacherReg.MeanTeacherReg(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmp=0.4,\n                 lamda_u=0.001,\n                 dim_in=None)\n> - Parameter:\n>> - ema_decay: Update weights for the exponential moving average.\n>> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4, then warmup is performed in the first 40 iterations.\n>> - lambda_u: The weight of unsupervised loss.\n>> - dim_in: the dim of the instances.\n\n#### LAMDA_SSL.Algorithm.Regression.PiModelReg\n> CLASS LAMDA_SSL.Algorithm.Regression.PiModelReg.PiModelReg(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmp=0.4,\n                 lamda_u=0.001,\n                 dim_in=None)\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n>> - warmup: The end position of warmup. For example, num_it_total is 100 and warmup is 0.4,\n                then warmup is performed in the first 40 iterations.\n>> - dim_in: the dim of the instances.\n\n### LAMDA_SSL.Algorithm.Clustering\n\n#### LAMDA_SSL.Algorithm.Clustering.Constrained_k_means\n> CLASS LAMDA_SSL.Algorithm.Cluster.Constrained_k_means.Constrained_k_means(k, tolerance=1e-7, max_iterations=300)\n> - Parameter:\n>> - k: The k value for the k-means clustering algorithm.\n>> - tolerance: Tolerance of iterative convergence.\n>> - max_iterations: The maximum number of iterations.\n\n#### LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means\n> CLASS LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means.Constrained_Seed_k_means(k, tolerance=0.00001, max_iterations=300)\n> - Parameter:\n>> - k: The k value for the k-means clustering algorithm.\n>> - tolerance: Tolerance of iterative convergence.\n>> - max_iterations: The maximum number of iterations.\n\n## LAMDA_SSL.Augmentation\n\n### LAMDA_SSL.Augmentation.Tabular\n\n#### LAMDA_SSL.Augmentation.Tabular.Noise\n> CLASS LAMDA_SSL.Transform.Noise.Noise(noise_level)\n> - Parameter:\n>> - noise_level: the level of noise.\n\n### LAMDA_SSL.Augmentation.Vision\n#### LAMDA_SSL.Augmentation.Vision.AutoContrast\n> CLASS LAMDA_SSL.Transform.AutoContrast.AutoContrast()\n\n#### LAMDA_SSL.Augmentation.Vision.Brightness\n> CLASS LAMDA_SSL.Transform.Brightness.Brightness(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.Color\n> CLASS LAMDA_SSL.Augmentation.Vision.Color.Color(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.Contrast\n> CLASS LAMDA_SSL.Augmentation.Vision.Contrast.Contrast(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.Equalize\n> CLASS LAMDA_SSL.Augmentation.Vision.Equalize.Equalize()\n\n#### LAMDA_SSL.Augmentation.Vision.Identity\n> CLASS LAMDA_SSL.Augmentation.Vision.Identity.Identity()\n\n#### LAMDA_SSL.Augmentation.Vision.Invert\n> CLASS LAMDA_SSL.Augmentation.Vision.Invert.Invert()\n\n#### LAMDA_SSL.Augmentation.Vision.Posterize\n> CLASS LAMDA_SSL.Augmentation.Vision.Posterize.Posterize(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n>> - scale: Scale of image pixel values.\n\n#### LAMDA_SSL.Augmentation.Vision.Rotate\n> CLASS LAMDA_SSL.Augmentation.Vision.Rotate.Rotate(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.Sharpness\n> CLASS LAMDA_SSL.Augmentation.Vision.Sharpness.Sharpness(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.ShearX\n> CLASS LAMDA_SSL.Augmentation.Vision.ShearX.ShearX(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.ShearY\n> CLASS LAMDA_SSL.Augmentation.Vision.ShearY.ShearY(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.Solarize\n> CLASS LAMDA_SSL.Augmentation.Vision.Solarize.Solarize(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n>> - scale: Scale of image pixel values\n\n#### LAMDA_SSL.Augmentation.Vision.TranslateX\n> CLASS LAMDA_SSL.Augmentation.Vision.TranslateX.TranslateX(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.TranslateY\n> CLASS LAMDA_SSL.Augmentation.Vision.TranslateY.TranslateY(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: The minimum value of the augmentation.\n>> - max_v: The maximum value of the augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - magnitude: The level of the augmentation.\n>> - v: Specify the value of the augmentation directly.\n\n#### LAMDA_SSL.Augmentation.Vision.RandomCrop\n> CLASS LAMDA_SSL.Augmentation.Vision.RandomCrop.RandomCrop(padding=None, pad_if_needed=False, fill=0, padding_mode=\"constant\")\n> - Parameter:\n>> - padding: Optional padding on each border of the image. Default is None. If a single int is provided this is used to pad all borders. If sequence of length 2 is provided this is the padding on left/right and top/bottom respectively. If a sequence of length 4 is provided this is the padding for the left, top, right and bottom borders respectively.\n>> - pad_if_needed: It will pad the image if smaller than the desired size to avoid raising an exception. Since cropping is done after padding, the padding seems to be done at a random offset.\n>> - fill: Pixel fill value for constant fill. Default is 0. If a tuple of length 3, it is used to fill R, G, B channels respectively. This value is only used when the padding_mode is constant. Only number is supported for torch Tensor. Only int or str or tuple value is supported for PIL Image.\n>> - padding_mode: Type of padding. Should be: constant, edge, reflect or symmetric. Default is constant.\n\n#### LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip\n> CLASS LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip.RandomHorizontalFlip()\n\n#### LAMDA_SSL.Augmentation.Vision.CutoutAbs\n> CLASS LAMDA_SSL.Augmentation.Vision.CutoutAbs.CutoutAbs.CutoutAbs(v,fill,random_v)\n> - Parameter:\n>> - v: The absolute value of the crop size.\n>> - fill: The padding value.\n>> - random_v: Whether to randomly determine the crop size.\n\n#### LAMDA_SSL.Augmentation.Vision.Cutout\n> CLASS LAMDA_SSL.Augmentation.Vision.Cutout.Cutout(v,fill,random_v=True)\n> - Parameter:\n>> - v: The relative value of crop size.\n>> - fill: The padding value.\n>> - random_v: Whether to randomly determine the crop size.\n\n#### LAMDA_SSL.Augmentation.Vision.RandAugment\n> CLASS LAMDA_SSL.Augmentation.Vision.RandAugment.RandAugment(n, m, num_bins,random=False,augment_list=None)\n> - Parameter:\n>> - n: The times of Random augmentation.\n>> - m: The magnitude of Random augmentation.\n>> - num_bins: The number of intervals  division for the value of the augmentation.\n>> - random: Whether to use random value for augmentation.\n>> - augment_list: The list of augmentations and their minimum and maximum values.\n\n#### LAMDA_SSL.Augmentation.Vision.Mixup\n> CLASS LAMDA_SSL.Transform.Mixup.Mixup(alpha)\n> - Parameter:\n>> - alpha: The parameter of the beta distribution.\n\n#### LAMDA_SSL.Augmentation.Text\n\n#### LAMDA_SSL.Augmentation.Text.RandomDeletion\n> CLASS LAMDA_SSL.Augmentation.Text.RandomDeletion.RandomDeletion(p,tokenizer=None)\n> - Parameter:\n>> - p: The proportion of random deletions.\n>> - tokenizer: The tokenizer used when the text is not untokenized.\n\n<!-- ### LAMDA_SSL.Augmentation.Text.RandomInsertion\n> CLASS LAMDA_SSL.Augmentation.Text.RandomInsertion(n=1,tokenizer=None)\n> - Parameter:\n>> - n: 增加单词的次数。\n>> - tokenizer: 分词方法。 -->\n\n#### LAMDA_SSL.Augmentation.Text.RandomSwap\n> CLASS LAMDA_SSL.Augmentation.Text.RandomSwap.RandomSwap(n=1,tokenizer=None)\n> - Parameter:\n>> - n: The number of times to swap words.\n>> - tokenizer: The tokenizer used when the text is not untokenized.\n\n#### LAMDA_SSL.Augmentation.Text.TFIDFReplacement\n> CLASS LAMDA_SSL.Augmentation.Text.TFIDFReplacement.TFIDFReplacement(text,p=0.7,tokenizer=None,cache_len=100000)\n> - Parameter:\n>> - text: The text that needs to be augmented.\n>> - p: Basic replacement probability.\n>> - tokenizer: The tokenizer used when the text is not untokenized.\n>> - cache_len: buffer size of Random numbers.\n\n### LAMDA_SSL.Augmentation.Graph\n\n#### LAMDA_SSL.Augmentation.Graph.DropNodes\n\n> CLASS LAMDA_SSL.Augmentation.Graph.DropNodes.DropNodes(num_drop, shuffle=True, random_state=None)\n> - Parameter:\n>> - num_drop: The number of nodes to be dropped.\n>> - shuffle: Whether to shuffle the data.\n>> - random_state: The random seed.\n\n#### LAMDA_SSL.Augmentation.Graph.DropEdges\n> CLASS LAMDA_SSL.Augmentation.Graph.DropEdges.DropEdges(num_drop, shuffle=True, random_state=None)\n> - Parameter:\n>> - num_drop: The number of edges to be dropped.\n>> - shuffle: Whether to shuffle the data.\n>> - random_state: The random seed.\n\n## LAMDA_SSL.Base\n\n### LAMDA_SSL.Base.BaseSampler\n> CLASS LAMDA_SSL.Base.BaseSampler.BaseSampler()\n> - init_sampler(data_source):  Initialize the sampler with data.\n>> - data_source: The data to be sampled.\n\n### LAMDA_SSL.Base.BaseOptimizer\n> CLASS LAMDA_SSL.Base.BaseOptimizer.BaseOptimizer(defaults)\n> - Parameter:\n>> - defaults: A dict containing default values of optimization options (used when a parameter group doesn't specify them).\n> - init_optimizer(params): Put the parameters that need to be optimized into the optimizer.\n>> - params: The parameters to be optimized.\n\n### LAMDA_SSL.Base.BaseScheduler\n> CLASS LAMDA_SSL.Base.BaseScheduler(last_epoch=-1, verbose=False)\n> - Parameter:\n>> - last_epoch: The index of last epoch.\n>> - verbose: If 'True', prints a message to stdout for each update.\n> - init_scheduler(optimizer): Initialize the scheduler with the optimizer.\n>> - optimizer: The optimizer used by the model.\n\n### LAMDA_SSL.Base.LambdaLR\n> CLASS LAMDA_SSL.Base.LambdaLR(lr_lambda, last_epoch=-1,verbose=False)\n> - Parameter:\n>> - lr_lambda: A function which computes a multiplicative factor given an integer parameter epoch, or a list of such functions, one for each group in optimizer.param_groups.\n>> - last_epoch: The index of last epoch.\n>> - verbose: If 'True', prints a message to stdout for each update.\n\n### LAMDA_SSL.Base.TabularMixin\n> CLASS LAMDA_SSL.Base.TabularMixin.TabularMixin():\n> - init_transform: Initialize the default data transformation method.\n\n### LAMDA_SSL.Base.VisionMixin\n> CLASS LAMDA_SSL.Base.VisionMixin.VisionMixin(mean=None,std=None):\n> - Parameter:\n>> - mean: Mean of the dataset.\n>> - std: Standard deviation of the dataset.\n> - init_transform: Initialize the default data transformation method.\n\n### LAMDA_SSL.Base.TextMixin\n> CLASS LAMDA_SSL.Base.TextMixin.TextMixin(word_vocab=None,vectors=None,length=300,unk_token='<unk>',pad_token='<pad>',\n                 min_freq=1,special_first=True,default_index=None):\n> - Parameter:\n>> - word_vocab: A map that converts words to indexes.\n>> - vectors: Word vectors.\n>> - length: Length of each sentence.\n>> - unk_token: The token used to represent unknown words.\n>> - pad_token: The token used to represent padding.\n>> - min_freq: The minimum frequency required for a word to be used as a token in the word_vocab. It is valid when word_vocab is None and a mapping table needs to be constructed.\n>> - special_first: Whether to put special characters at the top of the mapping table.\n>> - default_index: The default value that should be used when converting a word to an index if it cannot be converted.\n> - init_default_transform: Initialize the data transformation method.\n\n### LAMDA_SSL.Base.GraphMixin\n> CLASS LAMDA_SSL.Base.GraphMixin.GraphMixin()\n> - init_transform: Initialize the default data transformation method.\n\n### LAMDA_SSL.Base.DeepModelMixin\n> CLASS LAMDA_SSL.Base.DeepModelMixin.DeepModelMixin(train_dataset=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None)\n> - Parameter:\n>> - train_dataset: Data manager for training data.\n>> - labeled_dataset: Data manager for labeled data.\n>> - unlabeled_dataset: Data manager for unlabeled data.\n>> - valid_dataset: Data manager for valid data.\n>> - test_dataset: Data manager for test data.\n>> - augmentation: Augmentation method, if there are multiple augmentation methods, you can use a dictionary or a list to pass parameters.\n>> - network: The backbone neural network.\n>> - epoch: Number of training epochs.\n>> - num_it_epoch: The number of iterations in each round, that is, the number of batches of data.\n>> - num_it_total: The total number of batches.\n>> - eval_epoch: Model evaluation is performed every eval_epoch epochs.\n>> - eval_it: Model evaluation is performed every eval_it iterations.\n>> - mu: The ratio of the number of unlabeled data to the number of labeled data.\n>> - optimizer: The optimizer used in training.\n>> - weight_decay: The optimizer's learning rate decay parameter.\n>> - ema_decay: The update scale for the exponential moving average of the model parameters.\n>> - scheduler: Learning rate scheduler.\n>> - device: Training equipment.\n>> - evaluation: Model evaluation metrics. If there are multiple metrics, a dictionary or a list can be used.\n>> - train_sampler: Sampler of training data.\n>> - labeled_sampler=None: Sampler of labeled data.\n>> - unlabeled_sampler=None: Sampler of unlabeled data.\n>> - train_batch_sampler=None: Batch sampler of training data\n>> - labeled_batch_sampler: Batch sampler of labeled data\n>> - unlabeled_batch_sampler: Batch sampler of unlabeled data\n>> - valid_sampler: sampler of valid data.\n>> - valid_batch_sampler: Batch sampler of valid data.\n>> - test_sampler: Sampler of test data.\n>> - test_batch_sampler: Batch sampler of test data.\n>> - parallel: Distributed training method.\n>> - file: Output file.\n\n### LAMDA_SSL.SemiEstimator.SemiEstimator\n> CLASS LAMDA_SSL.Base.SemiEstimator.SemiEstimator()\n> - fit(X,y,unlabeled_X): Train a SSL model.\n>> - X: Instances of labeled data.\n>> - y: Labels of labeled data.\n>> - unlabeled_X: Instances of unlabeled data.\n\n### LAMDA_SSL.InductiveEstimator.InductiveEstimator\n> CLASS LAMDA_SSL.Base.InductiveEstimator.InductiveEstimator()\n> - predict(X): Make predictions on the new data.\n>> - X: Samples to be predicted.\n\n### LAMDA_SSL.TransductiveEstimator.TransductiveEstimator\n> CLASS LAMDA_SSL.Base.TransductiveEstimator.TransductiveEstimator()\n> - predict(X=None,Transductive=True): Output the result of transductive learning or make predictions on the new data.\n>> - X: The samples to be predicted. It is only valid when Transductive is False.\n>> - Transductive: Whether to use transductive learning mechanism to directly output the prediction result of unlabeled_X input during fit.\n\n### LAMDA_SSL.Base.ClassifierEvaluation\n> CLASS LAMDA_SSL.Base.ClassifierEvaluation.ClassifierEvaluation()\n> - scoring(y_true,y_pred=None,y_score=None): Initialize the data transformation method.\n>> - y_true: Ground-truth labels.\n>> - y_pred: Hard labels for model predictions.\n>> - y_score: Soft labels for model predictions.\n\n### LAMDA_SSL.Base.RegressorEvaluation\n> CLASS LAMDA_SSL.Base.RegressorEvaluation.RegressorEvaluation()\n> - scoring(y_true,y_pred=None): Score the performace of the model.\n>> - y_true: Ground-truth labels.\n>> - y_pred: The results of model's predictions.\n\n### LAMDA_SSL.Base.ClusterEvaluation\n> CLASS LAMDA_SSL.Base.ClusterEvaluation.ClusterEvaluation()\n> - scoring(y_true=None,clusters=None,X=None): Initialize the data transformation method.\n>> - y_true: Ground-truth labels.\n>> - clusters: Clustering results.\n>> - X: Sample features used in clustering.\n\n### LAMDA_SSL.Base.Transformer\n> CLASS LAMDA_SSL.Base.Transformer.Transformer()\n> - fit(X,y=None): Obtain the processing function through existing data.\n>> - X: Samples for learning the function of transformation.\n>> - y: Labels for learning the function of transformation.\n> - transform(X): Process the new data.\n>> - X: Data to be converted.\n> - fit_transform(X,y=None): Firstly perform fit() on the existing samples X and labels y, and then directly transform y.\n>> - X: Samples for learning and transformation.\n>> - y: Labels fo learning\n\n## LAMDA_SSL.Dataloader\n\n### LAMDA_SSL.DataLoader.LabeledDataLoader\n\n> CLASS LAMDA_SSL.DataLoader.LabeledDataLoader.LabeledDataLoader(batch_size= 1, shuffle: bool = False,\n                 sampler = None, batch_sampler= None,\n                 num_workers: int = 0, collate_fn= None,\n                 pin_memory: bool = False, drop_last: bool = False,\n                 timeout: float = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor: int = 2, persistent_workers: bool = False)\n> - Parameter:\n>> - batch_size: How many samples per batch to load.\n>> - shuffle: Whether to shuffle the data.\n>> - sampler: The sampler used when loading data.\n>> - batch_sampler: set to True to have the data reshuffled at every epoch.\n>> - num_workers: How many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.\n>> - collate_fn: Merges a list of samples to form a mini-batch of Tensor(s).  Used when using batched loading from a map-style dataset.\n>> - pin_memory: If True, the data loader will copy Tensors into CUDA pinned memory before returning them.  If your data elements are a custom type, or your attr 'collate_fn' returns a batch that is a custom type, see the example below.\n>> - drop_last: Whether to discard redundant data that is not enough for a batch.\n>> - timeout: If positive, the timeout value for collecting a batch from workers. Should always be non-negative.\n>> - worker_init_fn: If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading.\n>> - multiprocessing_context: The context of multiprocessing.\n>> - generator: If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers.\n>> - prefetch_factor: Number of samples loaded in advance by each worker. '2' means there will be a total of 2 * num_workers samples prefetched across all workers.\n>> - persistent_workers: If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers 'Dataset' instances alive.\n\n### LAMDA_SSL.DataLoader.TrainDataLoader\n\n> CLASS LAMDA_SSL.DataLoader.TrainDataLoader.TrainDataLoader(\nbatch_size=1,\n                 shuffle = False, sampler = None,\n                 batch_sampler=None, Iterable = None,\n                 num_workers = 0, collate_fn = None,\n                 pin_memory = False, drop_last = True,\n                 timeout = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor = 2,\n                 persistent_workers= False,\n                 batch_size_adjust=False,labeled_dataloader=None,unlabeled_dataloader=None)\n> - Parameter:\n>> - batch_size: How many samples per batch to load.\n>> - shuffle: Whether to shuffle the data.\n>> - sampler: The sampler used when loading data.\n>> - batch_sampler: set to True to have the data reshuffled at every epoch.\n>> - num_workers: How many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.\n>> - collate_fn: Merges a list of samples to form a mini-batch of Tensor(s).  Used when using batched loading from a map-style dataset.\n>> - pin_memory: If True, the data loader will copy Tensors into CUDA pinned memory before returning them.  If your data elements are a custom type, or your attr 'collate_fn' returns a batch that is a custom type, see the example below.\n>> - drop_last: Whether to discard redundant data that is not enough for a batch.\n>> - timeout: If positive, the timeout value for collecting a batch from workers. Should always be non-negative.\n>> - worker_init_fn: If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading.\n>> - multiprocessing_context: The context of multiprocessing.\n>> - generator: If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers.\n>> - prefetch_factor: Number of samples loaded in advance by each worker. '2' means there will be a total of 2 * num_workers samples prefetched across all workers.\n>> - persistent_workers: If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers 'Dataset' instances alive.\n>> - batch_size_adjust: Whether to automatically adjust the batch_size of labeled_dataloader and unlabeled_dataloader according to the ratio of unlabeled samples to labeled samples.\n\n### LAMDA_SSL.DataLoader.UnlabeledDataLoader\n\n> CLASS LAMDA_SSL.DataLoader.UnlabeledDataLoader.UnlabeledDataLoader(batch_size= 1,\n                 shuffle: bool = False, sampler = None,\n                 batch_sampler= None,\n                 num_workers: int = 0, collate_fn= None,\n                 pin_memory: bool = False, drop_last: bool = False,\n                 timeout: float = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor: int = 2,\n                 persistent_workers: bool = False)\n> - Parameter:\n>> - batch_size: How many samples per batch to load.\n>> - shuffle: Whether to shuffle the data.\n>> - sampler: The sampler used when loading data.\n>> - batch_sampler: set to True to have the data reshuffled at every epoch.\n>> - num_workers: How many subprocesses to use for data loading. 0 means that the data will be loaded in the main process.\n>> - collate_fn: Merges a list of samples to form a mini-batch of Tensor(s).  Used when using batched loading from a map-style dataset.\n>> - pin_memory: If True, the data loader will copy Tensors into CUDA pinned memory before returning them.  If your data elements are a custom type, or your attr 'collate_fn' returns a batch that is a custom type, see the example below.\n>> - drop_last: Whether to discard redundant data that is not enough for a batch.\n>> - timeout: If positive, the timeout value for collecting a batch from workers. Should always be non-negative.\n>> - worker_init_fn: If not None, this will be called on each worker subprocess with the worker id (an int in [0, num_workers - 1]) as input, after seeding and before data loading.\n>> - multiprocessing_context: The context of multiprocessing.\n>> - generator: If not None, this RNG will be used by RandomSampler to generate random indexes and multiprocessing to generate base_seed for workers.\n>> - prefetch_factor: Number of samples loaded in advance by each worker. '2' means there will be a total of 2 * num_workers samples prefetched across all workers.\n>> - persistent_workers: If True, the data loader will not shutdown the worker processes after a dataset has been consumed once. This allows to maintain the workers 'Dataset' instances alive.\n\n## LAMDA_SSL.Dataset\n\n### LAMDA_SSL.Dataset.LabeledDataset\n\n> CLASS LAMDA_SSL.Dataset.LabeledDataset.LabeledDataset(transforms=None, transform=None, target_transform=None, pre_transform=None)\n> - Parameter:\n>> - pre_transform: The way to preprocess X before augmentation.\n>> - transforms: The way to transform X and y at the same time after data augmentation.\n>> - transform: The way to transform X after data augmentation.\n>> - target_transform: The way to transform y after data augmentation.\n\n### LAMDA_SSL.Dataset.UnlabeledDataset\n\n> CLASS LAMDA_SSL.Dataset.UnlabeledDataset.UnlabeledDataset(transforms=None, transform=None, target_transform=None, pre_transform=None)\n> - Parameter:\n>> - pre_transform: The way to preprocess X before augmentation.\n>> - transform: The way to transform X after data augmentation.\n\n### LAMDA_SSL.Dataset.TrainDataset\n\n> CLASS LAMDA_SSL.Dataset.TrainDataset.TrainDataset(transforms=None,\n                 transform=None,\n                 pre_transform=None,\n                 target_transform=None,\n                 unlabeled_transform=None,\n                 labeled_size=None,\n                 stratified=False,\n                 shuffle=True,\n                 random_state=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None\n                 )\n> - Parameter:\n>> - pre_transform: The way to preprocess X before augmentation.\n>> - transforms: The way to transform X and y at the same time after data augmentation.\n>> - transform: The way to transform X after data augmentation.\n>> - target_transform: The way to transform y after data augmentation.\n>> - unlabeled_transform: The way to transform unlabeled_X after data augmentation.\n>> - labeled_size: The number or proportion of labeled samples.\n>> - stratified: Whether to sample by class scale.\n>> - shuffle: Whether to shuffle the data.\n>> - random_state: The random seed.\n>> - labeled_dataset: The labeled dataset.\n>> - unlabeled_dataset: The unlabeled dataset.\n\n### LAMDA_SSL.Dataset.SemiDataset\n\n> CLASS LAMDA_SSL.Dataset.SemiDataset.SemiDataset(transforms=None,\n                 transform=None,\n                 pre_transform=None,\n                 target_transform=None,\n                 unlabeled_transform=None,\n                 valid_transform=None,\n                 test_transform=None,\n                 test_size=None,\n                 valid_size=None,\n                 labeled_size=None,\n                 stratified=False,\n                 shuffle=True,\n                 random_state=None):\n> - Parameter:\n>> - pre_transform: The way to preprocess X before augmentation.\n>> - transforms: The way to transform X and y at the same time after data augmentation.\n>> - transform: The way to transform X after data augmentation.\n>> - target_transform: The way to transform y after data augmentation.\n>> - unlabeled_transform: The way to transform unlabeled_X after data augmentation.\n>> - valid_transform: The way to transform valid X after data augmentation.\n>> - test_transform: The way to transform test X after data augmentation.\n>> - test_size: The number or proportion of test samples.\n>> - valid_size: The number or proportion of valid samples.\n>> - labeled_size: The number or proportion of labeled samples.\n>> - stratified: Whether to sample by class scale.\n>> - shuffle: Whether to shuffle the data.\n>> - random_state: The random seed.\n\n## LAMDA_SSL.Distributed\n\n### LAMDA_SSL.Distributed.DataParallel\n> CLASS LAMDA_SSL.Distributed.DataParallel.DataParallel(device_ids=None, output_device=None, dim=0)\n> - Parameter:\n>> - device_ids: Available GPUs.\n>> - output_device: The GPU where the output result is stored.\n>> - dim: The dimension of data aggregation from each device.\n\n### LAMDA_SSL.Distributed.DistributedDataParallel\n> CLASS LAMDA_SSL.Distributed.DistributedDataParallel.DistributedDataParallel(device_ids=None,\n        output_device=None,\n        dim=0,\n        broadcast_buffers=True,\n        process_group=None,\n        bucket_cap_mb=25,\n        find_unused_parameters=False,\n        gradient_as_bucket_view=False)\n> - Parameter:\n>> - device_ids: Available GPUs.\n>> - output_device: The GPU where the output result is stored.\n>> - dim: The dimension of data aggregation from each device.\n>> - broadcast_buffers: Flag that enables syncing (broadcasting) buffers of the module at beginning of the 'forward' function.\n>> - process_group: The process group to be used for distributed data all-reduction. If None, the default process group, which is created by func 'torch.distributed.init_process_group', will be used.\n>> - bucket_cap_mb: 'DistributedDataParallel' will bucket parameters into multiple buckets so that gradient reduction of each bucket can potentially overlap with backward computation. attr 'bucket_cap_mb' controls the bucket size in MegaBytes (MB).\n>> - find_unused_parameters: Traverse the autograd graph from all tensors contained in the return value of the wrapped module's 'forward' function. Parameters that don't receive gradients as part of this graph are preemptively marked as being ready to be reduced. In addition, parameters that may have been used in the wrapped module's 'forward' function but were not part of loss computation and thus would also not receive gradients are preemptively marked as ready to be reduced.\n>> - gradient_as_bucket_view: When set to True, gradients will be views pointing to different offsets of 'allreduce' communication buckets. This can reduce peak memory usage, where the saved memory size will be equal to the total gradients size. Moreover, it avoids the overhead of copying between gradients and 'allreduce' communication buckets. When gradients are views, detach_() cannot be called on the gradients. If hitting such errors, please fix it by referring to the meth '~torch.optim.Optimizer.zero_grad' function in 'torch/optim/optimizer.py' as a solution.\n\n\n## LAMDA_SSL.Evaluation\n\n### LAMDA_SSL.Evaluation.Classifier\n\n#### LAMDA_SSL.Evaluation.Classifier.Accuracy\n> CLASS LAMDA_SSL.Evaluation.Classifier.Accuracy.Accuracy(normalize=True, sample_weight=None)\n> - Parameter:\n>> - normalize: If False, returns the number of correctly classified samples.\n>> - sample_weight: The weight of each sample.\n\n#### LAMDA_SSL.Evaluation.Classifier.Recall\n> CLASS LAMDA_SSL.Evaluation.Classifier.Recall.Recall(labels=None,\n                 pos_label=1,\n                 average=\"binary\",\n                 sample_weight=None,\n                 zero_division=\"warn\")\n> - Parameter:\n> - labels: The set of contained labels.\n>> - pos_label: Positive label for binary classification.\n>> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n>> - sample_weight: The weight of each sample.\n>> - zero_division: The return value when the denominator is 0.\n\n#### LAMDA_SSL.Evaluation.Classifier.Precision\n> CLASS LAMDA_SSL.Evaluation.Classifier.Precision.Precision(labels=None,\n                pos_label=1,\n                average=\"binary\",\n                sample_weight=None,\n                zero_division=\"warn\")\n> - Parameter:\n>> - labels: The set of contained labels.\n>> - pos_label: Positive label for binary classification.\n>> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n>> - sample_weight: The weight of each sample.\n>> - zero_division: The return value when the denominator is 0.\n\n#### LAMDA_SSL.Evaluation.Classifier.Top_k_Accurary\n> CLASS LAMDA_SSL.Evaluation.Classification.Top_k_Accurary.Top_k_Accurary(k=2, normalize=True, sample_weight=None, labels=None)\n> - Parameter:\n>> - k: The k value of Top_k_accurary.\n>> - normalize: If False, returns the number of correctly classified samples.\n>> - sample_weight: The weight of each sample.\n>> - labels: The set of contained labels.\n\n#### LAMDA_SSL.Evaluation.Classifier.AUC\n> CLASS LAMDA_SSL.Evaluation.Classifier.AUC.AUC(average=\"macro\",\n                 sample_weight=None,\n                 max_fpr=None,\n                 multi_class=\"raise\",\n                 labels=None)\n> - Parameter:\n>> - average: The way to calculate the AUC mean, optional 'micro', 'macro', 'samples', 'weighted' or None.\n>> - sample_weight: The weight of each sample.\n>> - max_fpr: Used to determine the range when only a partial AUC is calculated.\n>> - multi_class: Method for handling multiple classes, optional 'raise', 'ovr', 'ovo'.\n>> - labels: The set of contained labels.\n\n#### LAMDA_SSL.Evaluation.Classifier.F1\n> CLASS LAMDA_SSL.Evaluation.Classifier.F1.F1(\nlabels=None,\n                 pos_label=1,\n                 average=\"binary\",\n                 sample_weight=None,\n                 zero_division=\"warn\")\n> - Parameter:\n>> - labels: The set of contained labels.\n>> - pos_label: Positive label for binary classification.\n>> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n>> - sample_weight: The weight of each sample.\n>> - zero_division: The return value when the denominator is 0.\n\n### LAMDA_SSL.Evaluation.Regressor\n\n#### LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error.Mean_Absolute_Error(sample_weight=None, multioutput=\"uniform_average\")\n> - Parameter:\n>> - sample_weight: The weight of each sample.\n>> - multioutput: Aggregation method for multiple outputs.\n\n#### LAMDA_SSL.Evaluation.Regressor.Median_Absolute_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Median_Absolute_Error.Median_Absolute_Error(sample_weight=None, multioutput=\"uniform_average\")\n> - Parameter:\n>> - sample_weight: The weight of each sample.\n>> - multioutput: Aggregation method for multiple outputs.\n\n#### LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error.Mean_Squared_Error(sample_weight=None, multioutput=\"uniform_average\",squared=True)\n> - Parameter:\n>> - sample_weight: The weight of each sample.\n>> - multioutput: Aggregation method for multiple outputs.\n>> - squared: If True, output the MSE loss, otherwise output the RMSE loss.\n\n\n#### LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error.Mean_Squared_Log_Error(sample_weight=None, multioutput=\"uniform_average\")\n> - Parameter\n>> - sample_weight: The weight of each sample.\n>> - multioutput: Aggregation method for multiple outputs.\n>> - squared: If True, output the MSLE loss, otherwise output the RMSLE loss.\n\n### LAMDA_SSL.Evaluation.Cluster\n\n#### LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score\n> CLASS LAMDA_SSL.Evaluation.Davies_Bouldin_Score.Davies_Bouldin_Score()\n\n#### LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score\n> CLASS LAMDA_SSL.Evaluation.Fowlkes_Mallows_Score.Fowlkes_Mallows_Score(sparse=False)\n> - Parameter:\n>> - sparse: Whether to use sparse matrices for computation.\n\n#### LAMDA_SSL.Evaluation.Cluster.Rand_Score\n> CLASS LAMDA_SSL.Evaluation.Rand_Score.Rand_Score()\n\n#### LAMDA_SSL.Evaluation.Cluster.Jaccard_Score\n> CLASS LAMDA_SSL.Evaluation.Jaccard_Score.Jaccard_Score(labels=None, pos_label=1,average=\"binary\",sample_weight=None,zero_division=\"warn\")\n> - Parameter:\n>> - labels: The set of contained labels.\n>> - pos_label: Positive label for binary classification.\n>> - average: The calculation method for multi-classification, optional 'micro', 'macro', 'samples', 'weighted', 'binary'.\n>> - sample_weight: The weight of each sample.\n>> - zero_division: The return value when the denominator is 0.\n\n#### LAMDA_SSL.Evaluation.Cluster.Silhouette_Score\n> CLASS LAMDA_SSL.Evaluation.Silhouette_Score.Silhouette_Score(metric=\"euclidean\", sample_size=None, random_state=None)\n> - Parameter:\n>> - metric : The metric to use when calculating distance between instances in a feature array. If metric is a string, it must be one of the options allowed by <sklearn.metrics.pairwise.pairwise_distances>. If 'X' of the 'scoring' method is the distance array itself, use metric=\"precomputed\".\n>> - sample_size: The size of the sample to use when computing the Silhouette Coefficient on a random subset of the data.\n>> - random_state : Determines random number generation for selecting a subset of samples.\n\n## LAMDA_SSL.Loss\n### LAMDA_SSL.LOSS.Consistency\n> CLASS LAMDA_SSL.LOSS.Consistency.LOSS.Consistency.Consistency(reduction='mean',activation_1=None,activation_2=None)\n>> Parameter:\n>> - reduction: How to handle the output.\n> - forward(logits_1,logits_2): Perform loss calculations.\n>> - logits_1: The first input to compute consistency.\n>> - logits_2: The second input to compute consistency.\n\n### LAMDA_SSL.LOSS.Cross_Entropy\n> CLASS LAMDA_SSL.LOSS.Cross_Entropy.Cross_Entropy(use_hard_labels=True, reduction='none')\n> - Parameter:\n>> - use_hard_labels: Whether to use hard labels in the consistency regularization.\n>> - reduction: How to handle the output.\n> - forward(logits, targets): Perform loss calculations.\n>> - logits: The output of the model.\n>> - targets: The target result.\n\n### LAMDA_SSL.LOSS.KL_Divergence\n> CLASS LAMDA_SSL.LOSS.KL_Divergence.KL_Divergence(softmax_1=True, softmax_2=True, reduction='mean')\n> - Parameter:\n>> - softmax_1: Whether to softmax the first input.\n>> - softmax_2: Whether to softmax the second input.\n>> - reduction: How to handle the output.\n> - forward(logits_1,logits_2): Perform loss calculations.\n>> - logits_1: The first input to compute consistency.\n>> - logits_2: The second input to compute consistency.\n\n### LAMDA_SSL.LOSS.MSE\n> CLASS LAMDA_SSL.LOSS.MSE.MSE(reduction='mean',activation_1=None,activation_2=None)\n> - Parameter:\n>> - reduction: How to handle the output.\n>> - activation_1: The activation function to process on the first input.\n>> - activation_2: The activation function to process on the second input.\n> - forward(logits_1,logits_2): Perform loss calculations.\n>> - logits_1: The first input to compute consistency.\n>> - logits_2: The second input to compute consistency.\n\n### LAMDA_SSL.LOSS.EntMin\n> CLASS LAMDA_SSL.LOSS.EntMin.EntMin(reduction='mean', activation=None)\n> - Parameter:\n>> - reduction: How to handle the output.\n>> - activation: The activation function to process on the logits.\n> - forward(logits): Perform loss calculations.\n>> - logits: The logits to calculate the loss.\n\n### LAMDA_SSL.LOSS.Semi_Supervised_Loss\n> CLASS LAMDA_SSL.LOSS.Semi_Supervised_Loss.Semi_Supervised_Loss(lambda_u)\n> - Parameter:\n>> - lambda_u: The weight of unsupervised loss.\n> - forward(sup_loss,unsup_loss): Perform loss calculations.\n>> - sup_loss: The supervised loss.\n>> - unsup_loss: The unsupervised loss.\n\n## LAMDA_SSL.Network\n\n### LAMDA_SSL.Network.GAT\n> CLASS LAMDA_SSL.Network.GAT.GAT(dim_in,num_classes, dim_hidden=16,  heads=8, dropout=0.6)\n> - Parameter:\n>> - dim_in: Node feature dimension.\n>> - dim_hidden: the dimension of hidden layers.\n>> - num_classes: Number of classes.\n>> - dropout: The dropout rate.\n>> - heads: The number of heads.\n\n### LAMDA_SSL.Network.GCN\n> CLASS LAMDA_SSL.Network.GCN.GCN(dim_in,num_classes,dim_hidden=16,normalize=False)\n> - Parameter:\n>> - dim_in: The number of features.\n>> - num_classes: The number of classes.\n>> - normalize: Whether to add self-loops and compute symmetric normalization coefficients on the fly.\n\n### LAMDA_SSL.Network.ImprovedGAN\n\n> CLASS LAMDA_SSL.Network.ImprovedGAN.ImprovedGAN\n(G=None, D=None,dim_in = 28 ** 2,\n                 hidden_G=[1000,500,250,250,250],\n                 hidden_D=[1000,500,250,250,250],\n                 noise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5],\n                 activations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus(),nn.Softplus(), nn.Softplus(), nn.Softplus()],\n                 activations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 output_dim = 10,z_dim=100,device='cpu')\n> - Parameter:\n>> - G: The neural network of generator.\n>> - D: The neural network of discriminator\n>> - dim_in: The dimension of the inputted samples.\n>> - hidden_G: The dimension of the generator's hidden layers.\n>> - hidden_D: The dimension of the discriminator's hidden layers.\n>> - activations_G: The activation functions for each layer of the generator.\n>> - activations_D: The activation functions for each layer of the discriminator.\n>> - output_dim: The dimension of outputs.\n>> - z_dim: The dimension of the hidden variable used to generate data.\n>> - device: The device to train the model.\n\n### LAMDA_SSL.Network.LadderNetwork\n\n> CLASS LAMDA_SSL.Network.LadderNetwork.LadderNetwork\n(encoder_sizes=[1000, 500, 250, 250, 250],\n                 encoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 noise_std=0.2,dim_in=28*28,num_classes=10,device='cpu')\n> - Parameter:\n>> - encoder_sizes: The neural network of generator.\n>> - encoder_activations: The activation functions of the encoder.\n>> - noise_std: The standard deviation of the noise.\n>> - dim_in: The dimension of the input samples。\n>> - num_classes: The number of classes.\n>> - device: The device to train the model.\n\n### LAMDA_SSL.Network.MLPReg\n\n> CLASS LAMDA_SSL.Network.MLPReg.MLPReg(dim_in = 28 ** 2,hidden_dim=[10],activations=[nn.ReLU()])\n> - Parameter:\n>> - input_dim: The dimension of input samples.\n>> - hidden_dim: The dimension of hidden layers.\n>> - activations: The activation functions used in the hidden layers.\n\n### LAMDA_SSL.Network.ResNet50\n\n> CLASS LAMDA_SSL.Network.ResNet50.ResNet50(block= Bottleneck,\n            layers = [3, 4, 6, 3],\n            num_classes = 1000,\n            zero_init_residual= False,\n            groups = 1,\n            width_per_group = 64,\n            replace_stride_with_dilation = None,\n            norm_layer = None)\n> - Parameter:\n>> - block: The basic network module.\n>> - layers: The number of repetitions of modules with hidden layers of 64, 128, 256, and 512 dimensions.\n>> - num_classes: The number of classes.\n>> - zero_init_residual: Whether to initialize residual with 0.\n>> - groups: The number of groups to compute in parallel.\n>> - width_per_group: The number of convolution kernels in each group.\n>> - replace_stride_with_dilation: A list or tuple of 3 bool variables. It represents whether to perform convolution expansion for 64, 128, and 256-dimensional modules.\n>> - norm_layer: Regularization method. The default is BatchNorm2d.\n\n### LAMDA_SSL.Network.SDNE\n> CLASS LAMDA_SSL.Network.SDNE.SDNE(dim_in, hidden_layers, device=\"cpu\")\n> - Parameter:\n>> - input_dim: The dimension of the input samples.\n>> - hidden_layers: The dimension of the hidden layers.\n>> - device: The device to train the model.\n\n### LAMDA_SSL.Network.SSVAE\n> CLASS LAMDA_SSL.Network.SSVAE.SSVAE(dim_in,num_classes,dim_z,dim_hidden_de=[500,500],\n                 dim_hidden_en_y=[500,500],dim_hidden_en_z=[500,500],\n                 activations_de=[nn.Softplus(),nn.Softplus()],\n                 activations_en_y=[nn.Softplus(),nn.Softplus()],\n                 activations_en_z=[nn.Softplus(),nn.Softplus()],\n                 device='cpu')\n> - Parameter:\n>> - dim_in: The dimension of the input sample.\n>> - num_classes: The number of classes.\n>> - dim_z: The dimension of the hidden variable z.\n>> - dim_hidden_de: The hidden layer dimension of the decoder.\n>> - dim_hidden_en_y: The hidden layer dimension of the encoder for y.\n>> - dim_hidden_en_z: The hidden layer dimension of the encoder for z.\n>> - activations_de: The activation functions of the decoder.\n>> - activations_en_y: The activation functions of the encoder for y.\n>> - activations_en_z: The activation functions of the encoder for z.\n>> - device: The device to train the model.\n\n### LAMDA_SSL.Network.TextRCNN\n> CLASS LAMDA_SSL.Network.TextRCNN.TextRCNN(n_vocab,embedding_dim=300,len_seq=300, padding_idx=None, hidden_size=256, num_layers=1,\n                 dropout=0.0, pretrained_embeddings=None,num_class=2)\n> - Parameter:\n>> - n_vocab: The size of the dictionary.\n>> - embedding_dim: The dimension of the word embedding.\n>> - len_seq: The length of the sentence.\n>> - padding_idx: If specified, the entries at 'padding_idx' do not contribute to the gradient; therefore, the embedding vector at 'padding_idx' is not updated during training, i.e. it remains as a fixed \"pad\". For a newly constructed Embedding, the embedding vector at 'padding_idx' will default to all zeros, but can be updated to another value to be used as the padding vector.\n>> - hidden_size: The dimension of the hidden layer.\n>> - num_layers: The number of network layers.\n>> - dropout: The dropout rate.\n>> - pretrained_embeddings: The pretrained word embeddings.\n\n### LAMDA_SSL.Network.WideResNet\n> CLASS LAMDA_SSL.Network.WideResNet.WideResNet(num_classes=10, depth=28, widen_factor=2, drop_rate=0.0)\n> - Parameter:\n>> - num_classes: The number of classes.\n>> - depth: The depth of network.\n>> - widen_factor: The width of the network.It is used to determine hidden layer dimensions.\n>> - dropout: The dropout rate.\n\n## LAMDA_SSL.Optimizer\n\n### LAMDA_SSL.Optimizer.Adam\n> CLASS LAMDA_SSL.Optimizer.Adam.Adam(lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, amsgrad=False)\n> - Parameter:\n>> - lr: learning rate.\n>> - betas: Coefficients used for computing running averages of gradient and its square.\n>> - eps: Term added to the denominator to improve numerical stability\n>> - weight_decay: Weight decay (L2 penalty)\n>> - amsgrad: whether to use the AMSGrad variant of this algorithm from the paper 'On the Convergence of Adam and Beyond'.\n\n### LAMDA_SSL.Optimizer.SGD\n> CLASS LAMDA_SSL.Optimizer.SGD.SGD((lr=0.01, momentum=0, dampening=0, weight_decay=0, nesterov=False)\n> - Parameter:\n>> - lr: Learning rate.\n>> - momentum: Momentum factor.\n>> - dampening: Dampening for momentum.\n>> - weight_decay: Weight decay (L2 penalty).\n>> - nesterov: Enables Nesterov momentum.\n\n## LAMDA_SSL.Sampler\n\n### LAMDA_SSL.Sampler.BatchSampler\n> CLASS LAMDA_SSL.Sampler.BatchSampler.BatchSampler(batch_size, drop_last)\n> - Parameter:\n>> - batch_size: The number of samples in each batch.\n>> - drop_last: Whether to discard samples less than one batch.\n> - init_sampler(sampler): Initialize batch sampler with sampler.\n>> sampler: The sampler used to initial batch sampler.\n\n### LAMDA_SSL.Sampler.SequentialSampler\n> CLASS LAMDA_SSL.Sampler.SequentialSampler.SequentialSampler()\n> - init_sampler(data_source):  Initialize the sampler with data.\n>> - data_source: The data to be sampled.\n\n### LAMDA_SSL.Sampler.RandomSampler\n> CLASS LAMDA_SSL.Sampler.RandomSampler.RandomSampler(replacement = False, num_samples = None, generator=None)\n> - Parameter:\n>> - replacement: samples are drawn on-demand with replacement if True.\n>> - num_samples: The number of samples\n>> - generator: Generator used in sampling.\n\n### LAMDA_SSL.Sampler.DistributedSampler\n> CLASS LAMDA_SSL.Sampler.DistributedSampler.DistributedSampler(num_replicas=None, rank=None, shuffle=True, seed=0, drop_last=False)\n> - Parameter:\n>> - num_replicas: The Number of processes participating in distributed training.\n>> - rank : Rank of the current process within 'num_replicas'.\n>> - shuffle: Whether to shuffle the data.\n>> - seed: The random seed.\n>> - drop_last: Whether to discard samples less than one batch.\n\n## LAMDA_SSL.Scheduler\n\n### LAMDA_SSL.Scheduler.CosineAnnealingLR\n> CLASS LAMDA_SSL.Scheduler.CosineAnnealingLR.CosineAnnealingLR(T_max, eta_min=0, last_epoch=-1, verbose=False)\n> - Parameter:\n>> - T_max: Maximum number of iterations.\n>> - eta_min: Minimum learning rate.\n>> - last_epoch: The index of last epoch.\n>> - verbose: If 'True', prints a message to stdout for each update.\n\n### LAMDA_SSL.Scheduler.StepLR\n> CLASS LAMDA_SSL.Scheduler.StepLR.StepLR(step_size, gamma=0.1, last_epoch=-1, verbose=False)\n> - Parameter:\n>> - step_size: Period of learning rate decay.\n>> - gamma: Multiplicative factor of learning rate decay.\n>> - last_epoch: The index of last epoch.\n>> - verbose: If 'True', prints a message to stdout for each update.\n\n### LAMDA_SSL.Scheduler.LinearWarmup\n> CLASS LAMDA_SSL.Scheduler.LinearWarmup.LinearWarmup(num_training_steps,\n                 num_warmup_steps=0,\n                 start_factor=0,\n                 end_factor=1,\n                 last_epoch=-1，verbose=True)\n> - Parameter:\n>> - num_training_steps: The total number of iterations for training.\n>> - num_warmup_steps: The number of iterations to warm up.\n>> - start_factor: The initialchange factor of the learning rate.\n>> - end_factor: The final change factor of the learning rate.\n>> - last_epoch: The index of the last epoch.\n>> - verbose: Whether to output redundant information.\n\n### LAMDA_SSL.Scheduler.CosineWarmup\n> CLASS LAMDA_SSL.Scheduler.CosineWarmup.CosineWarmup(num_training_steps, num_training_steps, num_warmup_steps=0, num_cycles=7./16, last_epoch=-1,verbose=True) \n> - Parameter:\n>> - num_training_steps: The total number of iterations for training.\n>> - num_warmup_steps: The number of iterations to warm up.\n>> - num_cycles: The upperbound of the multiplicative factor is num_cycles PI.\n>> - last_epoch: The index of the last epoch.\n>> - verbose: Whether to output redundant information.\n\n## LAMDA_SSL.Search\n### LAMDA_SSL.Search.BayesSearchCV\n> CLASS LAMDA_SSL.Search.BayesSearchCV.BayesSearchCV(estimator,param_distributions,n_iter=10,random_state=None,warm_up=2,lam=3,y_max=1, xi=0.01, kappa=None,acquisition_func='PI',scoring=None,n_jobs=None,refit=True,cv=None,verbose=0,pre_dispatch=\"2*n_jobs\",error_score=np.nan,return_train_score=True,)\n> - Parameter:\n>> - estimator: This is assumed to implement the scikit-learn estimator interface.\n>> - param_distributions: Dictionary with parameters names ('str') as keys and distributions or lists of parameters to try. Distributions must provide a 'rvs' method for sampling (such as those from scipy.stats.distributions). If a list is given, it is sampled uniformly. If a list of dicts is given, first a dict is sampled uniformly, and then a parameter is sampled using that dict as above.\n>> - n_iter: Number of iterations.\n>> - random_state: The state of random seed. \n>> - warm_up: The number of times to randomly sample parameters in the initial state.\n>> - lam: The number of parameter groups that need to be sampled for evaluation per iteration.\n>> - y_max: Valid when acquisition_func is 'PI' and 'EI', it represents the maximum value of the score.\n>> - xi: Valid when acquisition_func is 'PI' and 'EI', the parameter used to trade off exploration and explotitation.\n>> - kappa: Valid when acquisition_func is 'UCB', it is used to trade off mean and variance.\n>> - acquisition_func: The function to estimate the score of the parameter group, optional 'PI', 'EI' and 'UCB' or a function that can be called.\n>> - scoring: Strategy to evaluate the performance of the cross-validated model on the test set.\n>> - n_jobs: Number of jobs to run in parallel.\n>> - refit: Refit an estimator using the best found parameters on the whole dataset.\n>> - cv: Determines the cross-validation splitting strategy. Int, cross-validation generator or an iterable.\n>> - verbose: Controls the verbosity: the higher, the more messages.\n>> - pre_dispatch: Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process.\n>> - error_score: Value to assign to the score if an error occurs in estimator fitting.\n>> - return_train_score: If 'False', the 'cv_results_' attribute will not include training scores.\n\n### LAMDA_SSL.Search.EvolutionaryStrategySearchCV\n> CLASS LAMDA_SSL.Search.EvolutionaryStrategySearchCV.EvolutionaryStrategySearchCV(estimator,param_distributions,n_iter=10,random_state=None,scoring=None,n_jobs=None,refit=True,cv=None,verbose=0,pre_dispatch=\"2*n_jobs\",error_score=np.nan,return_train_score=True,)\n> - Parameter:\n>> - estimator: This is assumed to implement the scikit-learn estimator interface.\n>> - param_distributions: Dictionary with parameters names ('str') as keys and distributions or lists of parameters to try. Distributions must provide a 'rvs' method for sampling (such as those from scipy.stats.distributions). If a list is given, it is sampled uniformly. If a list of dicts is given, first a dict is sampled uniformly, and then a parameter is sampled using that dict as above.\n>> - n_iter: Number of iterations.\n>> - random_state: The state of random seed. \n>> - warm_up: The number of times to randomly sample parameters in the initial state.\n>> - lam: The value of \\lambda in the 1+\\lambda evolution strategy, that is, the number of children in each iteration.\n>> - scoring: Strategy to evaluate the performance of the cross-validated model on the test set.\n>> - n_jobs: Number of jobs to run in parallel.\n>> - refit: Refit an estimator using the best found parameters on the whole dataset.\n>> - cv: Determines the cross-validation splitting strategy. Int, cross-validation generator or an iterable.\n>> - verbose: Controls the verbosity: the higher, the more messages.\n>> - pre_dispatch: Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process.\n>> - error_score: Value to assign to the score if an error occurs in estimator fitting.\n>> - return_train_score: If 'False', the 'cv_results_' attribute will not include training scores.\n\n### LAMDA_SSL.Search.BayesSearchCV\n> CLASS LAMDA_SSL.Search.BayesSearchCV.BayesSearchCV(estimator,param_distributions,meta_learner=SVR(),n_iter=10,random_state=None,warm_up=2,lam=3,scoring=None,n_jobs=None,refit=True,cv=None,verbose=0,pre_dispatch=\"2*n_jobs\",error_score=np.nan,return_train_score=True,)\n> - Parameter:\n>> - estimator: This is assumed to implement the scikit-learn estimator interface.\n>> - param_distributions: Dictionary with parameters names ('str') as keys and distributions or lists of parameters to try. Distributions must provide a 'rvs' method for sampling (such as those from scipy.stats.distributions). If a list is given, it is sampled uniformly. If a list of dicts is given, first a dict is sampled uniformly, and then a parameter is sampled using that dict as above.\n>> - meta_learner: A meta-regressor for fitting parameters and scores.\n>> - n_iter: Number of iterations. \n>> - random_state: The state of random seed. \n>> - warm_up: The number of times to randomly sample parameters in the initial state.\n>> - lam: The number of parameter groups that need to be sampled for evaluation per iteration.\n>> - scoring: Strategy to evaluate the performance of the cross-validated model on the test set.\n>> - n_jobs: Number of jobs to run in parallel.\n>> - refit: Refit an estimator using the best found parameters on the whole dataset.\n>> - cv: Determines the cross-validation splitting strategy. Int, cross-validation generator or an iterable.\n>> - verbose: Controls the verbosity: the higher, the more messages.\n>> - pre_dispatch: Controls the number of jobs that get dispatched during parallel execution. Reducing this number can be useful to avoid an explosion of memory consumption when more jobs get dispatched than CPUs can process.\n>> - error_score: Value to assign to the score if an error occurs in estimator fitting.\n>> - return_train_score: If 'False', the 'cv_results_' attribute will not include training scores.\n\n## LAMDA_SSL.Split\n\n### LAMDA_SSL.Split.DataSplit\n> Function LAMDA_SSL.Split.DataSplit.DataSplit(stratified, shuffle, random_state=None, X=None, y=None,labeled_size=None)\n> - Parameter:\n>> - stratified: Whether to stratify by classes.\n>> - shuffle: Whether to shuffle the data.\n>> - random_state: The random seed.\n>> - X: Samples of the data to be split.\n>> - y: Labels of the data to be split.\n>> - labeled_size: The scale or size of the labeled data.\n\n### LAMDA_SSL.Split.ViewSplit\n> Function LAMDA_SSL.Split.ViewSplit.ViewSplit(X,num_splits=2,axis=1,shuffle=True)\n> - Parameter:\n>> - X: Samples of the data to be split.\n>> - num_splits: The number of views\n>> - axis: The axis of the dimension to be splited.\n>> - shuffle: Whether to shuffle the features.\n\n## LAMDA_SSL.Transform\n\n### LAMDA_SSL.Transform.Tabular\n\n#### LAMDA_SSL.Transform.Tabular.MinMaxScaler\n> CLASS LAMDA_SSL.Transform.Tabular.MinMaxScaler.MinMaxScaler(min_val=None,max_val=None)\n> - Parameter:\n>> - min_val: The minimum value.\n>> - max_val: The maximum value.\n\n#### LAMDA_SSL.Transform.Tabular.StandardScaler\n> CLASS LAMDA_SSL.Transform.Tabular.StandardScaler.StandardScaler(mean=None,std=None)\n> - Parameter:\n>> - mean: The value of mean.\n>> - std: The value of standard deviation.\n\n#### LAMDA_SSL.Transform.Tabular.MaxAbsScaler\n> CLASS LAMDA_SSL.Transform.Tabular.MaxAbsScaler.MaxAbsScaler(max_abs=None)\n> - Parameter:\n>> - max_abs: The max abs value.\n\n### LAMDA_SSL.Transform.Vision\n\n#### LAMDA_SSL.Transform.Vision.Normalization\n> CLASS LAMDA_SSL.Transform.Vision.Normalization.Normalization(mean=None,std=None)\n> - Parameter:\n>> - mean: The mean of normalization.\n>> - std: The standard deviation of normalization.\n\n#### LAMDA_SSL.Transform.Vision.Resize\n> CLASS LAMDA_SSL.Transform.Vision.Resize.Resize(size, interpolation = InterpolationMode.BILINEAR,\nmax_size = None, antialias = None)\n> - Parameter:\nsize: Desired output size. If size is a sequence like (h, w), the output size will be matched to this. If size is an int, the smaller edge of the image will be matched to this number maintaining the aspect ratio.\n> - interpolation: Desired interpolation enum defined by 'torchvision.transforms.InterpolationMode'.\n> - max_size: The maximum allowed for the longer edge of the resized image: if the longer edge of the image is greater than 'max_size' after being resized according to 'size', then the image is resized again so that the longer edge is equal to 'max_size'.\n> - antialias: antialias flag. If 'img' is PIL Image, the flag is ignored and anti-alias is always used. If 'img' is Tensor, the flag is False by default and can be set to True for 'InterpolationMode.BILINEAR' only mode. This can help making the output for PIL images and tensors closer.\n\n### LAMDA_SSL.Transform.Text\n\n#### LAMDA_SSL.Transform.Text.Tokenizer\n\n> CLASS LAMDA_SSL.Transform.Text.Tokenizer.Tokenizer(tokenizer, language='en')\n> - Parameter:\n>> - tokenizer: Function name for word segmentation, such as basic_english, spacy, moses, toktok, revtok, subword, etc.\n>> - language: The language of the text.\n\n#### LAMDA_SSL.Transform.Text.Vocab\n> CLASS LAMDA_SSL.Transform.Text.Vocab.Vocab(word_vocab=None,vectors=None,text=None,min_freq=1,specials=[\"<unk>\",\"<pad>\"],special_first=True,default_index=None,tokenizer=None)\n> - Parameter:\n>> - word_vocab: A map that converts words to indexes.\n>> - vectors: Word vectors.\n>> - text: When word_vocab is None, use text to create a mapping table.\n>> - min_freq: The minimum frequency required for a word to be used as a token in the word_vocab. It is valid when word_vocab is None and a mapping table needs to be constructed.\n>> - specials: List of special characters.\n>> - special_first: Whether to put special characters at the top of the mapping table.\n>> - default_index: The default value that should be used when converting a word to an index if it cannot be converted.\n>> - tokenizer: The word segmentation method used.\n\n#### LAMDA_SSL.Transform.Text.Vectors\n> CLASS LAMDA_SSL.Transform.Text.Vectors.Vectors(name, cache=None, url=None, unk_init=None,pad_init=None, max_vectors=None,lower_case_backup=True, pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - name: The name of the word vector.\n>> - cache: Directory for cached vectors。\n>> - url: The download address of the word vector.\n>> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - max_vectors: The maximum number of word vectors.\n>> - lower_case_backup: Whether to convert all to lowercase when looking up words.\n>> - pad_token: The default padding token.\n>> - unk_token: The default token represents unknown words.\n\n#### LAMDA_SSL.Transform.Text.CharNGram\n> CLASS LAMDA_SSL.Transform.Text.CharNGram.CharNGram(lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - lower_case_backup: Whether to convert all to lowercase when looking up words.\n>> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_token: The default padding token.\n>> - unk_token: The default token represents unknown words.\n\n#### LAMDA_SSL.Transform.Text.FastText\n> CLASS LAMDA_SSL.Transform.Text.FastText.FastText(language=\"en\",lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - language: Language type.\n>> - lower_case_backup: Whether to convert all to lowercase when looking up words.\n>> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_token: The default padding token.\n>> - unk_token: The default token represents unknown words.\n\n#### LAMDA_SSL.Transform.Text.GloVe\n> CLASS LAMDA_SSL.Transform.Text.GloVe.GloVe(name=\"840B\", dim=300,lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - name: The name of the word vector.\n>> - dim: The dimension of the word vector.\n>> - lower_case_backup: Whether to convert all to lowercase when looking up words.\n>> - unk_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_init: By default, initialize out-of-vocabulary word vectors to zero vectors; can be any function that takes in a Tensor and returns a Tensor of the same size.\n>> - pad_token: The default padding token.\n>> - unk_token: The default token represents unknown words.\n\n#### LAMDA_SSL.Transform.Text.Truncate\n> CLASS LAMDA_SSL.Transform.Text.Truncate.Truncate(length=100,pos=0)\n> - Paraameter:\n>> - length: The length of the truncated text.\n>> - pos: The position to start truncating.\n\n#### LAMDA_SSL.Transform.Text.PadSequence\n> CLASS LAMDA_SSL.Transform.Text.PadSequence.PadSequence(length,pad_val=None)\n> - Parameter:\n>> - length: The length of the text after padding.\n>> - pad_val: The padding value for insufficient length of text.\n\n#### LAMDA_SSL.Transform.Text.AdjustLength\n> CLASS LAMDA_SSL.Transform.Text.AdjustLength.AdjustLength(length, pad_val=None, pos=0)\n> - Parameter:\n>> - length: Length of adjusted sentence.\n>> - pad_val: The padding value for insufficient length of text.\n>> - pos；If the sentence is too long and needs to be cut, this parameter specifies the position to start cutting.\n\n### LAMDA_SSL.Transform.Graph\n\n#### LAMDA_SSL.Transform.Graph.NormalizeFeatures\n> CLASS LAMDA_SSL.Transform.Graph.NormalizeFeatures.NormalizeFeatures(attrs=[\"x\"])\n> - Parameter:\n>> - attrs: Properties that require regularization.\n\n#### LAMDA_SSL.Transform.Graph.GDC\n> CLASS LAMDA_SSL.Transform.Graph.GDC.GDC(self_loop_weight=1, normalization_in='sym',\n                 normalization_out='col',\n                 diffusion_kwargs=dict(method='ppr', alpha=0.15),\n                 sparsification_kwargs=dict(method='threshold',avg_degree=64),\n                 exact=True)\n> - Parameter:\n>> - self_loop_weight: Weight of the added self-loop. Set to None to add no self-loops.\n>> - normalization_in: Normalization of the transition matrix on the original (input) graph. Possible values: \"sym\", \"col\", and \"row\".\n>> - normalization_out: Normalization of the transition matrix on the transformed GDC (output) graph. Possible values: \"sym\", \"col\", and \"row\".\n>> - diffusion_kwargs: Dictionary containing the parameters for diffusion.\n>> - sparsification_kwargs: Dictionary containing the parameters for sparsification.\n>> - exact: Whether to accurately calculate the diffusion matrix.\n\n#### LAMDA_SSL.Transform.Graph.GCNNorm\n> CLASS LAMDA_SSL.Transform.Graph.GCNNorm.GCNNorm(add_self_loops=True)\n> - Parameter:\n>> - add_self_loops: Whether to add self loops.\n\n#### LAMDA_SSL.Transform.Graph.SVDFeatureReduction\n> CLASS LAMDA_SSL.Transform.Graph.SVDFeatureReduction.SVDFeatureReduction(out_channels)\n> - Parameter:\n>> - out_channels: The dimensionlity of node features after reduction.\n\n### LAMDA_SSL.Transform.ToImage\n> CLASS LAMDA_SSL.Transform.ToImage.ToImage(channels=3,channels_first=True)\n> - Parameter:\n>> - channels: The number of channels of input images.\n>> - channels_first: Whether the number of channels is before the image size.\n\n### LAMDA_SSL.Transform.ToNumpy\n> CLASS LAMDA_SSL.Transform.ToNumpy.ToNumpy()\n\n### LAMDA_SSL.Transform.ToTensor\n> CLASS LAMDA_SSL.Transform.ToTensor.ToTensor(dtype=None,image=False)\n> - Parameter:\n>> - dtype: The dtype of Tensor.\n>> - image: Whether the X is a image.\n\n# FAQ\n1. What is the difference of interfaces between LAMDA-SSL and the semi-supervised learning module of sklearn?\n\nThe fit() method of sklearn generally has two items, X and y. The label y corresponding to the unlabeled X is represented by -1. But in many binary classification tasks, -1 represents a negative class, which is easy to conflict. So the fit() method of LAMDA-SSL has three inputs of X, y and unlabeled_X.\n\n2. How to understand the DeepModelMixin module?\n\nThis module mainly makes deep learning and classical machine learning have the same interface. And in order to facilitate users to replace the corresponding components of deep learning, DeepModelMixin decouples components of pytorch.\n\n# Reference\n\n[1]\tVAN ENGELEN J E, HOOS H H. A survey on semi-supervised learning[J]. Machine Learning, 2020, 109(2): 373-440.\n\n[2]\tOUALI Y, HUDELOT C, TAMI M. An Overview of Deep Semi-Supervised Learning[J/OL]. arXiv:2006.05278 [cs, stat], 2020[2022-03-01]. http://arxiv.org/abs/2006.05278.\n\n[3]\tYANG X, SONG Z, KING I, et al. A Survey on Deep Semi-supervised Learning[J/OL]. arXiv:2103.00550 [cs], 2021[2022-03-01]. http://arxiv.org/abs/2103.00550.\n\n[4]\tSHAHSHAHANI B M, LANDGREBE D A. The Effect of Unlabeled Samples in Reducing the Small Sample Size Problem and Mitigating the Hughes Phenomenon[J]. IEEE Transactions on Geoscience and remote sensing, 1994, 32(5): 1087-1095.\n\n[5]\tJOACHIMS T. Transductive Inference for Text Classi cation using Support Vector Machines[C].  International Conference on Machine Learning, 1999, 99.\n\n[6]\tBELKIN M, NIYOGI P, SINDHWANI V. Manifold Regularization: A Geometric Framework for Learning from Labeled and Unlabeled Examples[J]. Journal of machine learning research, 2006, 7(11).\n\n[7]\tZHU X, GHAHRAMANI Z. Learning from Labeled and Unlabeled Data with Label Propagation[R], 2002.\n\n[8]\tZHOU D, BOUSQUET O, LAL T, et al. Learning with Local and Global Consistency[C]. Advances in Neural Information Processing Systems, 2003, Vol. 16.\n\n[9]\tYAROWSKY D. Unsupervised Word Sense Disambiguation Rivaling Supervised Methods[C]. 33rd Annual Meeting of the Association for Computational Linguistics. Cambridge, Massachusetts, USA: Association for Computational Linguistics, 1995: 189-196.\n\n[10]\tBLUM A, MITCHELL T. Combining labeled and unlabeled data with co-training[C]. Proceedings of the eleventh annual conference on Computational learning theory. Conference on Learning Theory, 1998: 92-100.\n\n[11]\tZHI-HUA ZHOU, MING LI. Tri-training: exploiting unlabeled data using three classifiers[J]. IEEE Transactions on Knowledge and Data Engineering, 2005, 17(11): 1529-1541. \n\n[12]\tBENNETT K P, DEMIRIZ A, MACLIN R. Exploiting Unlabeled Data in Ensemble Methods[C]. Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining, 2002.\n\n[13]\tMALLAPRAGADA P K, RONG JIN, JAIN A K, et al. SemiBoost: Boosting for Semi-Supervised Learning[J]. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2009, 31(11): 2000-2014.\n\n[14]\tZHOU Z H, LI M. Semi-Supervised Regression with Co-Training[C]. International Joint Conference on Artificial Intelligence, 2005, 5.\n\n[15]\tWAGSTAFF K, CARDIE C, ROGERS S, et al. Constrained K-means Clustering with Background Knowledge[C]. International Conference on Machine Learning, 2001, 1.\n\n[16]\tBASU S, BANERJEE A, MOONEY R. Semi-supervised Clustering by Seeding[C]//In Proceedings of 19th International Conference on Machine Learning. 2002.\n\n[17]\tRASMUS A, BERGLUND M, HONKALA M, et al. Semi-supervised Learning with Ladder Networks[C]. Advances in Neural Information Processing Systems, 2015, 28.\n\n[18]\tXIE Q, DAI Z, HOVY E, et al. Unsupervised Data Augmentation for Consistency Training[C]. Advances in Neural Information Processing Systems, 2020, 33: 6256-6268.\n\n[19]\tLAINE S, AILA T. Temporal Ensembling for Semi-Supervised Learning[C]. International Conference on Learning Representations, 2017, 4(5): 6.\n\n[20]\tTARVAINEN A, VALPOLA H. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results[C]. Advances in Neural Information Processing Systems, 2017, 30.\n\n[21]\tMIYATO T, MAEDA S ichi, KOYAMA M, et al. Virtual Adversarial Training: A Regularization Method for Supervised and Semi-Supervised Learning[J]. IEEE transactions on pattern analysis and machine intelligence, 2018, 41(8): 1979-1993.\n\n[22]\tLEE D H. Pseudo-Label : The Simple and Efficient Semi-Supervised Learning Method for Deep Neural Networks[C]. ICML 2013 Workshop : Challenges in Representation Learning (WREPL), 2013, 3(2): 869.\n\n[23]\tZHAI X, OLIVER A, KOLESNIKOV A, et al. S4L: Self-Supervised Semi-Supervised Learning[C]. Proceedings of the IEEE/CVF International Conference on Computer Vision. 2019: 1476-1485.\n\n[24]\tVERMA V, KAWAGUCHI K, LAMB A, et al. Interpolation Consistency Training for Semi-Supervised Learning[C]. International Joint Conference on Artificial Intelligence, 2019: 3635-3641\n\n[25]\tBERTHELOT D, CARLINI N, GOODFELLOW I, et al. MixMatch: A Holistic Approach to Semi-Supervised Learning[C]. Advances in Neural Information Processing Systems, 2019, 32.\n\n[26]\tZHANG B, WANG Y, HOU W, et al. Flexmatch: Boosting semi-supervised learning with curriculum pseudo labeling[J]. Advances in Neural Information Processing Systems, 2021, 34.\n\n[27]\tSOHN K, BERTHELOT D, LI C L, et al. FixMatch: Simplifying Semi-Supervised Learning with Consistency and Confidence[J]. 21.\n\n[28]\tBERTHELOT D, CARLINI N, CUBUK E D, et al. ReMixMatch: Semi-Supervised Learning with Distribution Alignment and Augmentation Anchoring[J/OL]. arXiv:1911.09785 [cs, stat], 2020[2022-03-02]. http://arxiv.org/abs/1911.09785.\n\n[29]\tSALIMANS T, GOODFELLOW I, ZAREMBA W, et al. Improved Techniques for Training GANs[C]. Advances in Neural Information Processing Systems, 2016, 29.\n\n[30]\tKINGMA D P, REZENDE D J, MOHAMED S, et al. Semi-Supervised Learning with Deep Generative Models[C]. Advances in neural information processing systems, 2014, 27.\n\n[31]\tWANG D, CUI P, ZHU W. Structural Deep Network Embedding[C]. Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2016: 1225-1234.\n\n[32]\tKIPF T N, WELLING M. Semi-Supervised Classification with Graph Convolutional Networks[C]. International Conference on Learning Representations, 2017.\n\n[33]    Velickovic, Petar, et al. Graph attention networks[C]. International Conference on Learning Representations, 2018.\n\n[34]\tPEDREGOSA F, VAROQUAUX G, GRAMFORT A, et al. Scikit-learn: Machine Learning in Python[J]. The Journal of Machine Learning Research, 2001, 12: 2825-2830.\n\n[35]\tZHANG H, CISSE M, DAUPHIN Y N, et al. mixup: Beyond Empirical Risk Minimization[C]. International Conference on Learning Representations, 2018. \n\n[36]\tSCARSELLI F, GORI M, TSOI A C, et al. The graph neural network model[J]. IEEE transactions on neural networks, 2008, 20(1): 61-80.\n\n[37]\tGASTEIGER J, WEISSENBERGER S, GÜNNEMANN S. Diffusion Improves Graph Learning[J/OL]. arXiv:1911.05485 [cs, stat], 2022. http://arxiv.org/abs/1911.05485.\n\n[38]\tDAVIES D, BOULDIN D. A Cluster Separation Measure[J]. IEEE Transactions on Pattern Analysis and Machine Intelligence, 1979, 2: 224-227.\n\n[39]\tFOWLKES E B, MALLOWS C L. A Method for Comparing Two Hierarchical Clusterings[J]. Journal of the American Statistical Association, 1983, 78(383): 553-569.\n\n[40]\tRAND W M. Objective Criteria for the Evaluation of Clustering Methods[J]. Journal of the American Statistical Association, 2012, 66(336): 846-850.\n\n[41]\tCUBUK E D, ZOPH B, SHLENS J, et al. Randaugment: Practical automated data augmentation with a reduced search space[C]. IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), 2020: 3008-3017."
  },
  {
    "path": "docs/_coverpage.md",
    "content": "<!-- _coverpage.md -->\n<img width=\"200px\" style=\"border-radius: 50%\" src=\"./Imgs/Logo.png\" > \n<!-- ![logo](Logo.png) -->\n\n# LAMDA-SSL <small>1.0</small>\n\n> A powerful and easy-to-use toolkit for semi-supervised learning.\n\n- \n- \n- \n\n[GitHub](https://github.com/YGZWQZD/Semi-sklearn/)\n[Get Started](?id=Introduction)\n"
  },
  {
    "path": "docs/_navbar.md",
    "content": "- [English](README.md?id=Introduction)\n- [中文](./zh-cn/README.md)\n"
  },
  {
    "path": "docs/_sidebar.md",
    "content": "- [Introduction](/README.md?id=Introduction)\n    - [Background](/README.md?id=Background)\n    - [Purpose](/README.md?id=Purpose)\n    - [Design Mode](/README.md?id=Design-Mode)\n        - [Data Module](/README.md?id=Data-Module)\n        - [Model Module](/README.md?id=Model-Module)\n    - [Application Scenarios](/README.md?id=Application-Scenarios)\n        - [Data Types](/README.md?id=Data-Types)\n        - [Task Types](/README.md?id=Task-Types)\n    - [Algorithms](/README.md?id=Algorithms)\n        - [Statistical Learning Algorithms](/README.md?id=Statistical-Learning-Algorithms)\n        - [Deep Learning Algorithms](/README.md?id=Deep-Learning-Algorithms)\n\n- [Usage Tutorial](/README.md?id=Usage-Tutorial)\n    - [Dataset Initialization](/README.md?id=Dataset-Initialization)\n    - [Data Transformation](/README.md?id=Data-Transformation)\n    - [Pipeline Mechanism](/README.md?id=Pipeline-Mechanism)\n    - [Train an Inductive Statistical Semi-Supervised classification Model](/README.md?id=Train-an-Inductive-Statistical-Semi-Supervised-classification-Model)\n    - [Train a Transductive Statistical Semi-Supervised Classification Model](/README.md?id=Train-a-Transductive-Statistical-Semi-Supervised-Classification-Model)\n    - [Train a Multi-view Statistical Semi-Supervised Classification Model](/README.md?id=Train-a-Multi-view-Statistical-Semi-Supervised-Classification-Model)\n    - [Train a statistical semi-supervised regression model](/README.md?id=Train-a-statistical-semi-supervised-regression-model)\n    - [Train a Statistical Semi-Supervised Clustering Model](/README.md?id=Train-a-Statistical-Semi-Supervised-Clustering-Model)\n    - [Train a Deep Semi-Supervised Model with Default Configuration](/README.md?id=Train-a-Deep-Semi-Supervised-Model-with-Default-Configuration)\n    - [Train a Custom-Configured Deep Semi-Supervised Model](/README.md?id=Train-a-Custom-Configured-Deep-Semi-Supervised-Model)\n    - [Train a Deep Semi-Supervised Text Classification Model](/README.md?id=Train-a-Deep-Semi-Supervised-Text-Classification-Model)\n    - [Train a Deep Semi-Supervised Regression Model](/README.md?id=Train-a-Deep-Semi-Supervised-Regression-Model)\n    - [Train a Deep Generative Model](/README.md?id=Train-a-Deep-Generative-Model)\n    - [Train a Deep Graph-based Model](/README.md?id=Train-a-Deep-Graph-based-Model)\n    - [Train a Distributed Deep Semi-Supervised Model](/README.md?id=Train-a-Distributed-Deep-Semi-Supervised-Model)\n    - [Model-Evaluation](/README.md?id=Model-Evaluation)\n    - [Model-Validation](/README.md?id=Model-Validation)\n    - [HyperParameters Search](/README.md?id=HyperParameters-Search)\n    - [Save and Load Models](/README.md?id=Save-and-Load-Models)\n    - [Custom Data](/README.md?id=Custom-Data)\n    - [Custom Data Transformation](/README.md?id=Custom-Data-Transformation)\n    - [Custom Sampler](/README.md?id=Custom-Sampler)\n    - [Custom Optimizer](/README.md?id=Custom-Optimizer)\n    - [Custom Learning Rate Scheduler](/README.md?id=Custom-Learning-Rate-Scheduler)\n    - [Custom Loss Function](/README.md?id=Custom-Loss-Function)\n    - [Custom Evaluation Metrics](/README.md?id=Custom-Evaluation-Metrics)\n    - [Custom Statistical Semi-Supervised Learning Algorithms](/README.md?id=Custom-Statistical-Semi-Supervised-Learning-Algorithms)\n    - [Custom Deep Semi-Supervised Learning Algorithm](/README.md?id=Custom-Deep-Semi-Supervised-Learning-Algorithm)\n\n- [User Guide](/README.md?id=User-Guide)\n    - [Statistical Semi-supervised Learning](/README.md?id=Statistical-Semi-supervised-Learning)\n        - [Generative Model](/README.md?id=Generative-Model)\n            - [SSGMM](/README.md?id=SSGMM)\n        - [Semi-supervised Support Vector Machine](/README.md?id=semi-supervised-support-vactor-machine)\n            - [TSVM](/README.md?id=TSVM)\n            - [LapSVM](/README.md?id=LapSVM)\n        - [Graph Based Method](/README.md?id=Graph-Based-Method)\n            - [Label Propagation](/README.md?id=Label-Propagation)\n            - [Label Spreading](/README.md?id=Label-Spreading)\n        - [Disagreement Based Method](/README.md?id=Disagreement-Based-Method)\n            - [Co-Training](/README.md?id=Co-Training)\n            - [Tri-Training](/README.md?id=Tri-Training)\n        - [Ensemble Method](/README.md?id=Ensemble-Method)\n            - [Assemble](/README.md?id=Assemble)\n            - [SemiBoost](/README.md?id=SemiBoost)\n        - [Semi-supervised Regression](/README.md?id=Semi-supervised-Regression)\n            - [CoReg](/README.md?id=CoReg)\n        - [Semi-supervised Cluster](/README.md?id=Semi-supervised-Cluster)\n            - [Constrained k-means](/README.md?id=Constrained-k-means)\n            - [Constrained Seed k-means](/README.md?id=Constrained-Seed-k-means)\n    - [Deep Semi-supervised Learning](/README.md?id=Deep-Semi-supervised-Learning)\n        - [Consistency Regularization](/README.md?id=Consistency-Regularization)\n            - [Ladder Network](/README.md?id=Ladder-Network)\n            - [UDA](/README.md?id=UDA)\n            - [Pi-Model](/README.md?id=Pi-Model)\n            - [Temporal-Ensembling](/README.md?id=Temporal-Ensembling)\n            - [MeanTeacher](/README.md?id=Mean-Teacher)\n            - [VAT](/README.md?id=VAT)\n        - [Pseudo Labeling](/README.md?id=Pseudo-Labeling)\n            - [Pseudo Label](/README.md?id=Pseudo-Label)\n            - [S4L](/README.md?id=S4L)\n        - [Hybird Method](/README.md?id=Hybird-Method)\n            - [ICT](/README.md?id=ICT)\n            - [MixMatch](/README.md?id=MixMatch)\n            - [ReMixMatch](/README.md?id=ReMixMatch)\n            - [FixMatch](/README.md?id=FixMatch)\n            - [FlexMatch](/README.md?id=FlexMatch)\n        - [Deep Generative Model](/README.md?id=Deep-Generative-Model)\n            - [ImprovedGAN](/README.md?id=ImprovedGAN)\n            - [SSVAE](/README.md?id=SSVAE)\n        - [Deep Graph Based Method](/README.md?id=Deep-Graph-Based-Method)\n            - [SDNE](/README.md?id=SDNE)\n            - [GCN](/README.md?id=GCN)\n            - [GAT](/README.md?id=GAT)\n\n- [API](/README.md?id=API)\n    - [LADMA_SSL.Algorithm](/README.md?id=lamda_sslalgorithm)\n    - [LADMA_SSL.Augmentation](/README.md?id=lamda_sslaugmentation)\n    - [LADMA_SSL.Base](/README.md?id=lamda_sslbase)\n    - [LADMA_SSL.Dataloader](/README.md?id=lamda_ssldataloader)\n    - [LADMA_SSL.Dataset](/README.md?id=lamda_ssldataset)\n    - [LADMA_SSL.Distributed](/README.md?id=lamda_ssldistributed)\n    - [LADMA_SSL.Evaluation](/README.md?id=lamda_sslevaluation)\n    - [LADMA_SSL.Loss](/README.md?id=lamda_sslloss)\n    - [LADMA_SSL.Network](/README.md?id=lamda_sslnetwork)\n    - [LADMA_SSL.Optimizer](/README.md?id=lamda_ssloptimizer)\n    - [LADMA_SSL.Sampler](/README.md?id=lamda_sslsampler)\n    - [LADMA_SSL.Scheduler](/README.md?id=lamda_sslscheduler)\n    - [LADMA_SSL.Split](/README.md?id=lamda_sslsplit)\n    - [LADMA_SSL.Transform](/README.md?id=lamda_ssltransform)\n\n- [FAQ](/README.md?id=faq)\n\n- [Reference](/README.md?id=reference)"
  },
  {
    "path": "docs/index.html",
    "content": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n  <meta charset=\"UTF-8\">\n  <title>Document</title>\n  <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge,chrome=1\" />\n  <meta name=\"description\" content=\"Description\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, minimum-scale=1.0\">\n  <link rel=\"stylesheet\" href=\"//cdn.jsdelivr.net/npm/docsify/themes/buble.css\">\n  <link rel=\"stylesheet\" href=\"//cdn.jsdelivr.net/npm/docsify-sidebar-collapse/dist/sidebar.min.css\" />\n  <link rel=\"stylesheet\" href=\"//cdn.jsdelivr.net/npm/docsify-sidebar-collapse/dist/sidebar-folder.min.css\" />\n  <link rel=\"stylesheet\" href=\"//cdn.jsdelivr.net/npm/katex@latest/dist/katex.min.css\"/>\n</head>\n<body>\n  <div id=\"app\"></div>\n  <script>\n    window.$docsify = {\n      name: 'LAMDA-SSL',\n      repo: 'https://github.com/YGZWQZD/LAMDA-SSL',\n      loadSidebar:true ,\n      // subMaxLevel:10,\n      coverpage:true,\n      loadNavbar:true,\n      // sidebarDisplayLevel:,\n      search: {\n        noData: {\n          '/': 'No result!'\n        },\n        paths: 'auto',\n        placeholder: {\n          '/': 'Search'\n        }\n      }\n    }\n  </script>\n  <script src=\"//unpkg.com/vue/dist/vue.js\"></script>\n  <script src=\"https://unpkg.com/docsify-demo-box-vue@{version}/dist/docsify-demo-box-vue.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/prismjs@1/components/prism-cklie.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/prismjs@1/components/prism-bash.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/docsify\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/docsify-sidebar-collapse/dist/docsify-sidebar-collapse.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/docsify/lib/plugins/search.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/docsify-pagination/dist/docsify-pagination.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/prismjs@1/components/prism-python.min.js\"></script>\n  <script src=\"//cdn.jsdelivr.net/npm/docsify-copy-code/dist/docsify-copy-code.min.js\"></script>\n  <script src=\"//unpkg.com/docsify-count/dist/countable.js\"></script> -->\n  <script src=\"//cdn.jsdelivr.net/npm/docsify-katex@latest/dist/docsify-katex.js\"></script>\n\n</body>\n</html>\n"
  },
  {
    "path": "docs/zh-cn/README.md",
    "content": "#  介绍\n\nLAMDA-SSL是一个有效易用的半监督学习工具包。LAMDA-SSL拥有完善的功能，便捷的接口和详细的文档。它将统计机器学习算法和深度学习算法集成到同一个框架中，与流行的机器学习工具包 sklearn 和流行的深度学习工具包 pytorch 兼容。支持sklearn的Pipeline机制和参数搜索功能，也支持pytorch的GPU加速和分布式训练功能。目前，LAMDA-SSL包含30个半监督学习算法，其中包括12个基于统计机器学习模型的算法和18个基于深度学习模型的算法。LAMDA-SSL包含了多样化的数据处理和增广方法，可用于4类数据：表格、图像、文本、图。LAMDA-SSL还拥有多样化的模型评估标准，可用于3类任务：分类、回归和聚类。LAMDA-SSL包含数据管理、数据转换、模型应用、模型部署多个模块，便于完成端到端的半监督学习过程。\n\n##  背景\n\n机器学习（Machine Learning）致力于研究如何利用经验（数据）改善计算机系统性能，是人工 智能（Artificial Intelligence）领域的核心技术。二十一世纪以来，机器学习与人工智能技术得到了 越来越多的关注。一方面，在学术界，人工智能相关的国际顶级会议参会人数和投稿数量节节攀升， 各高校陆续建立人工智能学院，开展人工智能与机器学习相关的学科教学。另一方面，在工业界， 人工智能与机器学习技术促进各传统行业融合创新，全面提升了制造、农业、物流、金融、商务、 家居等领域的智能化水平，同时也催生出大量新兴产业，如智能机器人、无人驾驶汽车等。全球主 要国家陆续发布文件部署启动人工智能与机器学习相关工作。例如，2017 年，我国国务院印发的《新 一代人工智能发展规划》中提到“人工智能是引领未来的战略性技术，世界主要发达国家把发展人 工智能作为提升国家竞争力、维护国家安全的重大战略”，将人工智能的发展提升到国家科技战略层 面；2018 年，美国发布《国防部人工智能战略》将人工智能与机器学习技术作为未来国防军事的重 要发展方向。 典型机器学习算法利用训练数据来构建预测模型，训练数据通常由特征（Feature）和标注（Label） 两部分组成，例如，我们希望训练一个“猫”和“狗”的图像分类模型，则特征表示输入的图片像 素，标注表示每张图片属于猫还是狗。目前机器学习的研究主要关注在监督学习（Supervised  Learning）场景中，即收集大量有标注数据作为训练集提供给机器学习算法，算法通过拟合训练数 据得到训练好的模型，最终在未见环境中测试部署学习得到的模型。然而，在现实任务中，数据标 注往往耗费大量的人力、物力和财力，导致大量的数据标注是难以获取。例如，在计算机辅助医学 图像分析任务中，如果希望医学专家把影像中的病灶全都标识出来是几乎不可能的。但是，与此同 时，无标注数据往往是非常容易获得的，可以从医院收集到大量无标注的医学影像。因此，当标注 数据不足时，如何利用易于获取的无标注数据提升机器学习泛化性能成为机器学习领域一个关键性 的问题。 半监督学习（Semi-Supervised Learning，SSL）是利用无标注数据提升机器学习泛化性能的代表 性技术。自二十世纪九十年代提出以来，半监督学习一直是机器学习领域热门的研究方向。尤其是 近年来，随着深度学习的发展，模型复杂度逐渐增加，对标注数据的需求量与日俱增，半监督学习 的研究吸引了越来越多学术界和工业界的关注。例如，2017 年以来，在 ICML/NeurIPS/ICLR/CVPR  等人工智能和机器学习顶级会议上，半监督学习相关论文热度高居前三名；在《国家科学评论》 （National Science Review，NSR）2018 年 1 月份出版的机器学习专题期刊中，南京大学周志华教 授发表题为《A brief introduction to weakly supervised learning》的综述论文，指出能够利用无标注数 据辅助模型训练的半监督学习是机器学习领域亟待解决的问题；2019 年谷歌首席科学家 Vincent  Vanhoucke 发文称“能够利用少量标注数据及大量无标注数据训练机器学习模型的半监督学习革命 已经到来”。由此可见，研究半监督学习算法，降低机器学习模型对数据标注的需求，已经得到了学 术界和工业界的广泛关注，是人工智能与机器学习领域发展的关键研究问题。 尽管半监督学习近年来取得了巨大的进展，但是相较于经典的机器学习范式，半监督学习领域 的发展目前存在训练流程更复杂、算法实现更困难，参考文档更匮乏等诸多难题，导致非半监督学 习专业研究人员难以成功应用半监督学习算法解决实际问题，严重限制了半监督学习在更多现实任 务中的落地转化。因此，设计并实现便捷易用的半监督学习开源工具包，推动半监督学习算法在实 际场景中的进一步落地，是半监督学习领域走出实验室，并在工业界扎根落地的重要问题。\n\n## 编写目的\n\n半监督学习问题的复杂程度为工具包开发者造成了严重的知识与技能壁垒，导致目前依然缺乏便捷易用的半监督学习工具包。而为了满足在实际应用中用户对于半监督学习技术的需求，一个成熟易用的半监督学习工具包应该具备以下特点：\n1）拥有先进的设计模式，同时从数据和算法角度考虑用户需求，使接口尽可能简单的同时功能尽可能强大；\n2）应用范围应足够广泛，如同时支持表格、图像、文本、图等多种常见数据类型，同时支持分类、回归、聚类等多种常见任务类型；\n3）拥有大量类型丰富且性能良好的算法供用户根据应用场景进行选择，可以同时支持统计机器学习算法和深度学习算法；\n4）具备易用性和可拓展性，同时考虑不同用户群体的需求，针对低熟练度的用户提供便捷的使用方法、默认参数与接口，针对高熟练度的用户应支持灵活的模块更换与自定义；\n5）通过大量实验验证工具包的有效性并比较算法在不同场景下的表现；\n6）拥有丰富便捷的文档供用户使用与参考。\n\n为了解决上述问题，我们开发了LAMDA-SSL这一设计模式先进、应用场景广泛、算法实现丰富、功能接口便捷、模型效果优秀、文档详尽完善的半监督学习工具包。目前该工具包涵盖30种半监督学习算法，其中基于统计机器学习模型的算法12种，基于深度神经网络模型的算法18种；包含多样的数据变换技术，可用于处理表格数据、图像数据、文本数据、图结构数据4种数据类型；包含多种模型评估方法，可用于分类、回归、聚类3种任务；包含数据管理、数据变换、模型应用、模型部署多个模块，便于实现端到端的半监督学习过程；兼容目前主流的机器学习工具包sklearn和深度学习工具包pytorch，支持sklearn的Pipeline机制和参数搜索功能，支持pytorch的GPU加速和分布式训练功能；为用户提供了便捷的工具包使用文档、详尽的API接口文档和丰富的半监督学习算法介绍文档；针对非专业用户提供了效果良好的默认参数，针对专业用户提供了便捷低耦合的模块修改与自定义接口。\n\nLAMDA-SSL是目前包含算法数量最多、支持数据类型最多、支持任务最多、功能最丰富、接口最便捷、文档最详尽的半监督学习工具包，也是首个将统计机器学习算法与深度学习算法融入同一框架并同时兼容sklearn和pytorch的半监督学习工具包。\n\n## 设计模式\n\nLAMDA-SSL相较其他的半监督学习工具，在设计模式方面更加先进，具备耦合度低、灵活性高、可拓展性强、接口简单等优势。基于这些优势，LAMDA-SSL可以帮助业界使用者快速上手半监督学习技术，以近乎零成本在业务中享受半监督学习带来的性能提升。\n\nLAMDA-SSL在设计上分为数据和模型两大模块（如图1所示），其中数据模块包含数据管理和数据变换，可用于表格、图像、文本和图四种数据类型，模型模块包含模型应用和模型部署，可用于分类、回归和聚类三种任务类型。\n\n<div align=center>\n\n<img width=1000px src=\"./Imgs/Overview.png\" >\n\n<br>\n\n图1: LAMDA-SSL的结构\n</div>\n\n### 数据模块\n\nLAMDA-SSL的数据模块设计思想如图2所示。\n\n<div align=center>\n\n<img width=1000px src=\"./Imgs/DataModule.png\" >\n\n<br>\n\n图2: LAMDA-SSL的数据模块\n\n</div>\n\n\nDataset：在LAMDA-SSL中，所有数据集都继承自pytorch的Dataset类，同时支持直接使用或分批次加载使用。一个半监督数据集整体可以用一个SemiDataset类进行管理，SemiDataset类可以同时管理TrainDataset 、ValidDataset、TestDataset三个子数据集，分别对应了机器学习任务中的训练数据集、验证数据集和测试数据集，在底层数据集分为LabeledDataset和UnlabeledDataset两类，分别对应了半监督学习中的有标注数据与无标注数据。训练集往往同时包含有标注数据和无标注数据，因此TrainDataset同时管理LabeledDataset和UnlabeledDataset两个数据集。\n\nData Transformation：在sklearn中，数据转换器同时继承了sklearn中的BaseEstimator和TransformerMixin，前者为sklearn的估计器基类，后者为sklearn的数据转换器组件，这使得数据转换器普遍拥有fit()和transform()两个方法，其中fit()方法根据现有数据学习数据处理方法，transform()方法用于对新的数据进行转换，有很大一部分转换器可以省略fit()的过程直接进行数据转换，数据转换器还可以通过fit_transform()接口连续完成fit()和transform()过程。在sklearn中数据转换器拥有Pipeline机制，可以对多个处理步骤进行流式封装和管理，LAMDA-SSL中的数据处理和数据增广方法都通过继承Transformer类拥有了与sklearn的数据转换器相同的功能。在深度半监督学习中，由于数据量庞大且可能需要根据算法需求进行数据增广，通常不会在模型训练前处理完所有数据，而是需要在数据加载过程中完成对数据的处理，因此需要为数据集设置数据处理方式，对数据加载器加载到的数据自动进行处理。在工具包TorchVision中，对数据有transform、target_transform、transforms三种处理，分别为对X、对y、同时对X和y进行变换。在半监督学习中，这三种方式并不能通用于所有情况，因此LAMDA-SSL针对无标注样本、验证样本、测试样本增加了unlabeled_transform、valid_ transform和test_transform三种数据处理流程，并且针对需要在数据处理流程中进行数据增广的情况增加了pre_transform流程，pre_transform和transform分别表示在数据增广前后对数据的处理，例如对于CIFAR10数据集，原始数据类型为numpy.ndarray，在需要数据增广的情况下，需要先转换为图片类型，对图片类型数据进行增广后再转化为torch.Tensor类型，则numpy.ndarray到图片和图片到torch.Tensor的转换过程分别对应了pre_transform和transform两种变换，二者之间可以根据算法需求灵活添加用户指定的数据增广方法。\n\nDataloader：在深度半监督学习中，通常数据量较大，需要通过采样器分批次加载数据，即每一次迭代通过采样获得数据的下标，通过__getitem__()方法进行索引，并将索引后的数据组合成torch.Tensor作为该轮迭代的批数据。LAMDA-SSL针对LabeledDataset和UnlabeledDataset分别设计了LabeledDataloader和UnlabeledDataloader两种数据加载器，并用一个TrainDataloader类同时管理两种加载器用于半监督学习的训练过程。除同时包含两个加载器外，TrainDataloader还起到调节两个加载器之间关系的作用，如调节无标注数据与有标注数据的采样总量比例和每一批次数据中无标注数据与有标注数据的比例。\n\nData-specific Mixin：LAMDA-SSL可以处理表格数据、图像数据、文本数据、图数据四种现实应用中常见的数据类型，分别使用了四个与数据类型对应的组件TableMixin、VisionMixin、TextMixin、GraphMixin进行处理，对于一个数据集，可以继承与其数据类型对应的组件获得组件中的数据处理功能。例如CIFAR10同时继承了SemiDataset和VisionMixin两个模块，从而拥有了默认的图像数据处理功能。而对于自定义数据集，用户可以通过覆盖SemiDataset中的init_dataset()方法设置数据集的数据来源，通过覆盖Mixin模块的init_default_transform()方法设置默认的数据处理流程。\n\n### 模型模块\n\nLAMDA-SSL的模型模块设计思想如图3所示。\n\n<div align=center>\n\n<img width=1000px src=\"./Imgs/ModelModule.png\" >\n<br>\n\n图3: LAMDA-SSL的模型模块\n</div>\n\nEstimator：LAMDA-SSL参考了sklearn工具包的底层实现，所有算法都使用了与sklearn相似的接口。 在sklearn中学习器都继承了BaseEstimator这一父类，普遍存在fit()和predict()两个方法。fit()方法利用现有数据建立模型，对应了机器学习中的训练过程；predict()方法利用fit()过后的模型对新数据进行预测，对应了机器学习中的预测过程。LAMDA-SSL中的学习器通过继承SemiEstimator间接继承了sklearn中的BaseEstimator。由于sklearn中fit()方法的输入仅包含样本和标注两项，而在半监督学习中，模型在训练过程中需要同时使用有标注样本、标注和无标注样本三项数据，因此BaseEstimator的fit()方法接口不便于直接用于半监督学习算法。虽然sklearn中也实现了自训练方法和基于图的方法两类半监督学习算法，但是为了使用fit()方法的接口，sklearn将有标注样本与无标注样本结合在一起作为fit()方法的样本输入，并将无标注样本对应的标注记为-1，这种处理方式虽然可以适应BaseEstimator的接口，但是也存在局限性，尤其是在一些二分类场景下往往用-1表示有标注样本的负例，与无标注样本会发生冲突，因此针对半监督学习在BaseEstimatorr的基础上重新建立新类SemiEstimator具有必要性。SemiEstimator的fit()方法包含有标注样本、标注和无标注样本三部分输入，更好地契合了半监督学习的应用场景，避免了要求用户对数据进行组合处理，也避免了无标注样本与二分类负类样本的冲突，相较BaseEstimator使用起来更加便捷。半监督学习一般分为归纳式学习和直推式学习，区别在于是否直接使用待预测数据作为训练过程中的无标注数据。其中归纳式算法使用有标注数据和已知无标注数据训练一个学习器，用于对未知无标注数据的标注进行预测；而直推式学习使用有标注数据和已知无标注数据直接预测已知无标注数据的标注。直推式方法也可以通过在原有算法的基础上加入一些新的机制拓展为归纳式方法，从而可以对新的待预测样本进行预测。LAMDA-SSL中使用两个类InductiveEstimator和TransductiveEstimator分别对应了归纳式学习和直推式学习两类半监督学习范式，均继承了SemiEstimator类。其中InductiveEstimator的predict()方法需要输入新的待预测样本，而TransductiveEstimator的predict()方法通过一个BOOL类型参数‘Transductive’确定是否采用直推式预测，如果为True，则不再需要输入新的样本，直接输出直推式预测结果，否则触发拓展机制，对新输入的样本进行预测。\n\n```python\nfrom sklearn.base import BaseEstimator\nfrom abc import ABC,abstractmethod\nclass SemiEstimator(ABC,BaseEstimator):\n    @abstractmethod\n    def fit(self,X,y,unlabeled_X):\n        raise NotImplementedError(\n            \"The fit() method of SemiEstimator must be implemented.\"\n        )\n```\n\nTask-specific Mixin：在sklearn中，为了使学习器针对不同的任务可以具备对应的功能，sklearn为学习器开发了与任务对应的组件，sklearn中的学习器往往会同时继承BaseEstimator和相应组件，从而使学习器除拥有基本的训练和预测功能外，还能拥有完成与组件对应的任务的功能。其中常用组件包括用于分类任务的ClassifierMixin、用于回归任务的RegressorMixin和用于聚类任务的ClusterMixin，在LAMDA-SSL中同样使用了这些组件。以TSVM算法为例，同时继承了TransductiveEstimator和ClassifierMixin两个模块，可用于直推式半监督分类任务。\n\nDeep SSL Model Mixin：不同于统计机器学习中常用的sklearn框架，深度学习中经常使用pytorch框架，其接口与sklearn的接口相差较大，导致很难将深度学习算法和统计机器学习算法融入同一框架。另外pytorch各组件间存在较大的依赖关系，耦合度高。在数据方面，批采样器（BatchSampler）依赖于采样器（Sampler），采样器依赖于数据集（Dataset），数据加载器（Dataloader）同时依赖于批采样器、采样器和数据集；在模型方面，调度器（Scheduler）依赖于优化器（Optimizer），优化器和分布式训练模块（Parallel）又依赖于神经网络模型(Network)。Pytorch的逻辑和接口相较sklearn较为复杂，对用户自身要求较高。为了解决统计机器学习方法和深度学习方法难以融合于相同框架的问题，LAMDA-SSL用DeepModelMixin这一组件使基于pytorch开发的深度半监督学习模型拥有了与统计半监督学习方法相同的接口和使用方式，LAMDA-SSL中的深度半监督学习算法都继承了这一组件。DeepModelMixin对pytorch各模块进行了解耦，便于用户独立更换或自定义深度学习中的数据加载器、网络结构、优化器等模块，而不需要考虑更换对其他模块造成的影响，DeepModelMixin会自动处理这些影响，使用户可以像调用统计半监督学习算法一样便捷地调用深度半监督学习算法。另外DeepModelMixin不仅支持用户更换深度学习中的组件，还对深度半监督学习模型的训练过程进行了解构，根据数据处理、前向传播、计算损失、模型优化等过程细分为了多个模块，便于用户对已有深度半监督学习算法进行调整或自定义新的深度半监督学习算法，避免了大量重复性工作。DeepModelMixin的结构如图4所示。\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/DeepModelMixin.png\" > \n\n<br>\n\n图4: LAMDA-SSL的DeepModolMixin\n</div>\n\nTask-specific Evaluation：LAMDA-SSL针对分类、回归、聚类三个任务提供了多样化的评估指标，用于对模型的评估和监控。LAMDA-SSL的模型评估有两种形式，第一种是在得到预测结果后调用评估模块，第二种是在学习器初始化时直接将评估指标作为学习器的属性，可以使模型在预测结束后直接完成评估过程，且对于深度半监督学习算法可以在模型训练过程中进行实时评估和反馈。针对三个不同任务的评估指标分别继承了ClassifierEvaluation、RegressorEvaluation、ClusterEvaluation三个基类。\n\n## 应用场景\n\nLAMDA-SSL应用场景广泛，可支持表格、图像、文本和图四种数据类型（如图5所示）以及分类、回归、聚类三种任务类型（如图6所示），能够在各种真实业务中发挥半监督算法的价值。\n\n### 数据场景\n\n\n<div align=center>\n<img width=\"600px\"  src=\"./Imgs/DataType.png\" >\n<br>\n图5: LAMDA-SSL的数据场景\n</div>\n\n表格数据是最基本的数据形式，其特征间和样本间均不存在空间与时间上的联系，统计机器学习算法中很大一部分都是针对表格数据而设计的，这一数据类型在用户画像、股票分析、网络异常检测等应用中广泛存在。对于表格数据，sklearn中的preprocessing模块已经提供了足够丰富的处理方法，如‘StandardScaler’、‘MinMaxScaler’、‘MaxAbsScaler’等，LAMDA-SSL在其基础上进行了补充。TableMixin模块提供了对表格数据的默认处理方式，将‘StandardScaler’作为默认预变换方法，在预变换后根据需求进行数据增广，如果应用于深度学习，再将数据转换为torch.Tensor形式。为了对表格数据进行数据增广，LAMDA-SSL实现了增广方法‘Noise’，即对标准化后的数据施加服从正态分布的噪声扰动，扰动幅度由正态分布的标准差控制。\n\n图像数据是深度学习领域最常用的数据类型之一，以张量形式被用于学习过程，其特征间存在空间位置上的联系，这一数据类型在医疗影像、自动驾驶、安防识别等领域都有广泛的应用。对于图像数据，TorchVision工具包提供了部分图像数据处理方法，如裁剪、旋转、锐化等，LAMDA-SSL在其基础上进行了补充。VisionMixin模块提供了对图像数据的默认处理方式，在预变换过程中将以其他形式存储的数据转化为图片格式，在预变换后根据需求进行数据增广，最后再由图像转化为模型可处理的数据类型。为了对图像数据进行数据增广，LAMDA-SSL提供了多种图像增广方法，包括‘RandomCrop’、‘RandomHorizontalFlip’等用于弱增广的方法以及‘RandAugment’、‘Cutout’等用于强增广的方法。\n\n文本数据是深度学习领域的另一种具有广泛应用场景的数据类型，带动了自然语言处理领域的迅速发展，文本往往通过各种嵌入方式被转化为向量，且数据特征间存在时序上的联系，这一数据类型在机器翻译、情感分析、信息检索等方面存在较为广泛的应用。对于文本数据，TorchText工具包提供了部分文本数据处理方法，如分词、词嵌入等，LAMDA-SSL在其基础上进行了补充。TextMixin模块提供了对文本数据的默认处理方式，首先在预处理阶段对文本进行分词，之后根据需求对文本进行数据增广，最后调整文本长度、通过字典将token转化为索引，在深度学习中由索引组成Tensor作为模型的输入，并在模型中根据索引得到词嵌入。LAMDA-SSL提供了多种文本增广方法，包括随机删除、交换等用于弱增广的方法和以及‘TF-IDF_Replacement’这一强增广方法，该方法的基本思想为通过TF-IDF值判断单词对于文本的重要程度，而替换不重要的单词不会对文本语义产生过大影响。\n\n图数据是近年来深度学习广泛关注的方向，不同于其他数据类型只在特征间存在空间与时间上的联系，图数据要考虑样本间的空间关系，即图的结构信息，这一数据类型在社交网络、药物发现、推荐系统等领域有着重要的应用前景。对于图数据，LAMDA-SSL以\ntorch_geometric中的图数据形式为标准，将图的结构信息、结点特征信息、结点标注信息等封装在数据集中，并通过mask的形式将结点划分为训练集、验证集和测试集，LAMDA-SSL在此基础上对训练集进行了进一步划分，增加了‘labeled_mask’和‘unlabeled_mask’。GraphMixin模块将对图中结点特征的标准化作为了默认的数据变换方式，并提供了‘Graph Diffusion Convolution’[36]、‘SVD Feature Reduction’、‘GCNNorm’等变换方法，通过在图中删除结点或边进行数据增广。\n\n<!-- 让表格居中显示的风格 -->\n<style>\n.center \n{\n  width: auto;\n  display: table;\n  margin-left: auto;\n  margin-right: auto;\n}\n</style>\n\n<div align=center class=\"center\">\n\n表1: LAMDA-SSL中的数据处理与数据增广\n\n|数据类型|数据处理|数据增广|\n|:-:|:-:|:-:|\n|表格|StandardScaler<br>MinMaxScaler<br>MaxAbsScaler|Noise|\n|图像|Resize<br>Normlization|RandomCrop<br>RandomHorizontalFlip<br>AutoContrast<br>Brightness<br>Color<br>Contrast<br>Rotate<br>Sharpness<br>Equalize<br>Solarize<br>Posterize<br>Invert<br>ShearX<br>ShearY<br>TranslateX<br>TranslateY<br>RandAugment<br>Cutout<br>CutoutAbs<br>Mixup|\n|文本|Tokenizer<br>Truncate<br>PadSquence<br>AdjustLength<br>Vocab<br>Vectors<br>Glove<br>FastText<br>CharNGram|RandomDeletion<br>RandomSwap<br>TFIDFReplacement|\n|图|GCNNorm<br> GDC<br> SVDFeatureReduction<br> NormalizeFeatures|DropNodes<br>DropEdges|\n\n</div>\n\n### 任务场景\n\n<div align=center>\n<img width=\"600px\"  src=\"./Imgs/TaskType.png\" > \n<br>\n图6: LAMDA-SSL的任务场景\n</div>\n\n分类任务是机器学习领域最基本的任务之一，模型的预测结果为离散值，常用于行为预测、目标识别、内容过滤等场景。对于分类任务，LAMDA-SSL提供了大量算法，以及‘Accuracy’、‘Recall’、‘Precision’、‘F1 Score’等多种评估指标，这些指标可以利用真实标注、模型预测的硬标注以及软标注完成对模型表现的评估。\n\n回归任务是机器学习领域另一基本任务，模型的预测结果为连续值，常用于价格预测、销量预测和信用评分等场景。目前半监督回归领域的相关研究还未成熟，可用算法较少，尤其是缺乏深度学习算法。LAMDA-SSL中除了包含半监督回归算法CoReg外，还对部分用于分类的深度半监督学习算法进行了拓展，使他们能够适用于回归任务，并提供了绝对误差、均方误差、均方对数误差多种评估指标。\n\n聚类任务是无监督学习最经典的应用，其无法利用真实标注建立特征空间与目标空间的联系，在异常检测、客户管理、价值组合等不存在真实标注的场景下有着广泛应用。对于聚类任务，LAMDA-SSL中的算法都在原有无监督聚类的基础上引入了部分监督信息来引导聚类过程，使聚类结果与真实标注更加吻合。LAMDA-SSL提供了两类聚类评估指标，第一类是外部指标，即存在正确的参考结果，通过比较聚类结果与参考结果的差异评估模型表现，更适用于数据本身存在标注的情况，如‘Fowlkes Mallows Score’[38]、‘Rand Score’[39]等，以聚类结果和参考结果为输入；第二类是内部指标，不依赖于参考结果，仅根据样本自身特征和聚类结果评估模型表现，如‘Davies Bouldin Score’[37]、‘Silhouette Score’等，以聚类结果和样本特征为输入。\n\n<div align=center class=\"center\">\n\n表2: LAMDA-SSL中的评估指标\n\n|任务类型|评估指标|\n|:-:|:-:|\n|分类|Accuracy<br>Top k Accuracy<br>Recall<br>Precision<br>F1 Score<br>AUC<br>Confusion Matrix|\n|回归|Mean Absolute Error<br>Mean Squared Error<br>Mean Squared Log Error|\n|聚类|Davies Bouldin Score<br>Fowlkes Mallows Score<br>Jaccard Score<br>Rand Score<br>Silhouette Score|\n\n</div>\n\n## 算法实现\n\nLAMDA-SSL实现了多达30中半监督学习算法，其中包括了12种统计机器学习算法和18种深度学习算法，为用户提供了多样化的选择。\n\n### 基于统计机器学习模型的半监督学习算法\n\nLAMDA-SSL包含12种基于统计机器学习模型的半监督学习算法（如图7所示），其中用于分类任务的算法包括生成式方法SSGMM，半监督支持向量机类方法TSVM、LapSVM，基于图的方法Label Propagation、Label Spreading，基于分歧的方法Co-Training、Tri-Training，集成方法SemiBoost、Assemble；用于回归任务的算法包括CoReg；用于聚类任务的算法包括Constrained K Means、Constrained Seed K Means。\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/Statistical.png\" > \n\n<br>\n\n图7: LAMDA-SSL中的统计机器学习算法\n</div>\n\n生成式半监督学习方法基于生成式模型，其假设数据由一潜在的分布生成而来，而半监督生成式方法将无标注数据的标注视为隐变量，采用期望-最大化（EM）算法进行极大似然估计求解。SSGMM即半监督高斯混合模型，假设数据由一个高斯混合模型生成，即样本特征的边缘分布可以表示为若干个高斯分布混合在一起的结果，且通过混合参数为每个高斯分布赋予一个权重，对于无标注样本，可以将高斯混合成分与类别一一对应，并分类为权重最高的高斯混合成分对应的类别。\n\n半监督支持向量机是支持向量机算法在半监督学习领域的推广。半监督支持向量机引入了低密度假设，即学习得到的超平面除了需要基于有标注样本使分类间隔尽可能大，也要尽可能穿过所有样本分布的低密度区域，从而合理利用无标注样本。TSVM是最基础的半监督支持向量机方法，通过在迭代过程中不断交换可能分错的异类无标注样本对的伪标注完成学习。LapSVM引入了流形正则化，构建图模型并通过Laplace正则项引导模型对于图中临近样本的预测结果尽可能一致，从而利用样本在流形上的分布使无标注样本参与学习过程。\n\n基于图的半监督学习方法将数据集表示为一个图结构模型，图中同时存在有标注结点与无标注结点，因此基于图的半监督学习可以被视为标注在图中传播的过程。Label Propagation算法是其中最基础的方法，以Laplace正则项为优化目标，求解无标注数据的标注使优化目标取最小值。Label Spreading算法在Label Propagation算法的基础上，取消了在传递过程中模型对有标注样本的预测结果必须等于其真实标注这一限制，而是对错误结果进行了惩罚。\n\n基于分歧的半监督学习方法需要生成具有显著分歧、性能尚可的多个学习器，利用学习器之间的分歧对无标注数据加以利用，这类方法较少受到模型假设、损失函数非凸性和数据规模问题的影响，学习方法简单有效、理论基础相对坚实、适用范围较为广泛。Co-Training算法使用两个基学习器，通过不同数据视图产生分歧，利用多视图的相容互补性互相促进训练。Tri-training使用三个基本学习器，通过“少数服从多数”产生伪标注，并将学习器进行集成产生最终预测结果。\n\n集成学习方法将多个弱学习器结合起来，提高了模型的可靠性。在半监督学习领域，由于无标注数据的加入，单一学习器的不稳定性进一步加剧，对有效的集成学习方法有更强的依赖。Assemble即适应性半监督集成方法，是适应性提升（AdaBoost）方法的拓展，每一轮迭代通过当前集成学习器为无标注样本赋予伪标注，并根据模型预测结果与样本当前标注的差异自适应地调整样本采样权重。SemiBoost进一步考虑了样本间的关系，基于图半监督学习方法，指出应该对样本间相似度较高但目前集成学习器的预测结果不一致性较大的样本设置更大的采样权重。\n\n半监督回归算法相较于分类算法更难提出合理的假设，研究半监督回归相较半监督分类有着更多的困难，目前这一领域还有待更多的研究成果。CoReg将Co-Training算法引入了回归任务，由于在回归任务中难以像分类任务一样通过类别分布得到自信度，CoReg将加入一个无标注样本前后均方误差的差异作为自信度的评估标准，从而完成了Co-Training的训练过程。\n\n半监督聚类算法在原本无监督聚类的基础上引入了监督信息以辅助无监督学习的过程，其中监督信息不一定是有标注数据，也可能是其他与真实标注有关的知识。Constrained k-means在k-means聚类算法的基础上引入了称为必连（Must Link）和勿连（Connot Link）的约束作为监督信息，其中必连约束限制了一些样本必须属于同一聚类簇，而勿连约束限制了一些样本必须属于不同的聚类簇，且必连约束与勿连约束存在传递机制。Constrained Seed k-means不同于Constrained k-means将必连和勿连约束作为监督信息，而是直接将少量数据标注作为监督信息。\n\n\n### 基于深度学习模型的半监督学习算法\n\nLAMDA-SSL包含18种基于深度模型的半监督学习算法（如图8所示）：其中用于分类任务的算法包括一致性正则方法Ladder Network、Π Model、Temporal Ensembling、Mean Teacher、VAT、UDA，基于伪标注的方法Pseudo Label、S4L，混合方法ICT、MixMatch、ReMixMatch、FixMatch、FlexMatch，生成式方法ImprovedGAN、SSVAE，基于深度图模型的方法SDNE、GCN、GAT；用于回归任务的算法包括一致性正则方法Π Model Reg、Mean Teacher Reg和混合方法ICT Reg。\n\n<div align=center>\n\n<img width=\"1000px\"  src=\"./Imgs/Deep.png\" > \n\n<br>\n\n图8: LAMDA-SSL中的深度机器学习算法\n</div>\n\n一致性正则方法基于一致性假设，即假设对于样本增加一定程度的扰动，其预测结果应尽可能保持不变，可以利用大量无标注数据提升模型对于噪声的稳健性。Ladder network采用了对称的自编码器结构，将数据在加噪的情况下编码后的解码结果与不加噪情况下的编码结果间每一隐层的不一致性作为无监督损失。UDA即无监督数据增广，对无标注数据进行一次数据增广之后比较增广前后模型的数据的预测结果，利用均方误差损失计算一致性正则项作为无监督损失。Π Model对数据进行两次随机数据增广，并分别将两次增广的结果作为神经网络模型的输入进行预测，将预测结果的不一致性作为无监督损失。Temporal Ensembling对Π Model进行了一些改进，将两次增广后的预测结果中的一次改为对历史伪标注的指数移动平均（EMA），缓解了模型对历史信息的遗忘并减少了算力消耗。Mean Teacher借助了知识蒸馏的思想，且教师模型并非是复杂模型，而是在学生模型的基础上对模型参数进行指数移动平均。VAT不同于其他方法对数据增加随机噪声，而是对数据增加对抗噪声，使模型在数据受一定限制条件下噪声影响时的最坏表现不会太差。\n\n基于伪标注的方法通过为无标注数据赋以伪标注使无标注数据对学习过程产生影响。且由于模型对于不同样本的自信度不同，基于伪标注的方法通常取自信度较高的样本参与训练过程。Pseudo Label方法设置了一个自信度阈值，在每一次迭代中，对于无标注数据选择自信度高于阈值的部分计算交叉熵损失作为无监督损失。S4L利用了自监督技术，利用旋转等方式构造自监督任务，且目标任务与自监督任务共享同一表示层，以自监督标注为伪标注，使模型可以利用无标注数据学到更好的隐层表示。\n\n混合方法不局限于仅使用一类技术，而是将一致性、伪标注技术进行结合，各取所长，从而达到更好的训练效果。由于同时使用了多种技术，混合方法往往更加具备通用性。ICT即插值一致性训练，通过Mixup数据增广方法对数据与预测结果进行线性插值，将模型对插值后样本的预测结果与模型对原始数据的预测结果的插值之间的不一致性作为无监督损失。MixMatch也用了Mixup方法，但不同于ICT仅对无标注数据的样本与伪标注进行Mixup，MixMatch将有标注数据与无标注数据混合在一起，并对混合后的数据样本及其标注或伪标注进行了Mixup。ReMixMatch是MixMatch的改进版本，其引入了两种技术：分布对齐和增广锚定，分布对齐目的在于使模型对于无标注数据预测得到的伪标注应与有标注数据的标注有相同的概率分布，增广锚定是为了使模型适应更强的数据增广，使伪标注不会随增广强度增大而改变。FixMatch对样本进行了强数据增广与弱数据增广，并将模型对弱增广数据与强增广数据预测结果的不一致性作为无监督损失。FlexMatch是对于FixMatch的改进，并注重于解决半监督学习中各类别间的不公平现象，对不同类别采用不同的阈值进行样本筛选，缓解了因学习难度不同造成的类别不平衡现象。\n\n深度生成式方法利用真实数据对数据分布进行建模，并且可以利用这一分布生成新的数据。不同于经典的生成式方法，深度生成式方法基于深度神经网络生成数据，其中大部分工作是对生成对抗网络（GAN）和变分自编码器（VAE）的推广。ImprovedGAN的判别器不同于GAN模型，不仅需要判断样本是真实样本还是生成样本，还要完成对真实样本的分类。SSVAE将VAE模型的编码器分为了两个部分，第一部分对原始数据进行编码得到样本标注的概率分布，第二部分将原始数据与伪标注共同作为输入得到隐变量的概率分布。\n\n基于图深度学习的方法针对原始数据是图数据的情况。图中实例之间并非独立关系，而是通过边相连。现实中的图数据任务往往都是半监督的，即图中同时存在有标注结点与无标注结点。SDNE是一种可以在图中结点没有特征表示，仅有图结构信息的情况下学习图中结点嵌入向量的半监督图深度学习方法，该方法采用了自编码器结构，通过将结点的邻接向量作为特征输入自编码器学习得到结点的嵌入表示。GCN更适用于结点本身存在特征的情况，可以同时利用结点自身的特征信息和图结构信息进行学习，通过图卷积将近邻结点的信息进行汇集并更新结点表示。GAT和GCN同样适用于结点本身存在特征的情况，不同于GCN的图卷积操作，GAT引入了注意力机制，每次迭代根据当前结点自身的表示和近邻结点的的表示计算注意力权重，并利用权重对当前结点的表示进行更新。\n\n# 使用教程\n\n## 数据导入\n\n以CIFAR10数据集为例,首先导入CIFAR10类。\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n```\n\n实例化一个封装好的CIFAR10数据集,相当于一个数据管理器，root参数表示数据集存放地址，labeled_size参数表示有标注样本的数量或比例，stratified参数表示对数据集进行划分时是否要按类别比例划分，shuffle参数表示是否需要对数据集进行打乱，download参数表示是否需要下载数据集。\n\n```python\ndataset=CIFAR10(root='..\\LAMDA_SSL\\Download\\cifar-10-python',labeled_size=4000,stratified=False,shuffle=True,download=False)\n```\n\n可以通过访问封装数据集参数的方法获取数据集中的具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n## 数据变换\n\n以RandAugment[40]数据增广为例，首先导入RandAugment类。\n\n```python\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\n```\n\n对RandAugment进行实例化，参数n为进行随机增广的次数，表示增广的幅度，num_bins表示幅度划分的级别数。这里设置将增广幅度划分为10个等级，并采用第10级的增广增广2次。\n\n```python\naugmentation=RandAugment(n=2,m=10,num_bins=10)\n```\n\n之后输入数据完成数据增广。有两种方式：可以调用fit_transform()方法：\n\n```python\naugmented_X=augmentation.fit_transform(X)\n```\n\n也可以直接调用__call__()方法：\n\n```python\naugmented_X=augmentation(X)\n```\n\n## Pipeline机制\n\nLAMDA-SSL支持Pipeline机制，将多种数据处理方式以流水线的形式用于数据处理。\n如在FixMatch算法中的强数据增广和弱数据增广。\n\n```python\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\n\nweak_augmentation = Pipeline([('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect')),\n                                ])\n\nstrong_augmentation = Pipeline([('RandAugment', RandAugment(n=2, m=5, num_bins=10, random=True)),\n                                  ('Cutout', Cutout(v=0.5, fill=(127, 127, 127))),\n                                  ('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                  ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect')),\n                                  ])\n```\n\n可以直接调用fit_transform()方法完成数据处理。\n\n```python\nweak_augmented_X=weak_augmentation.fit_transform(X)\nstrong_augmented_X=strong_augmentation.fit_transform(X)\n```\n\n## 训练一个归纳式统计半监督分类模型\n\n以SSGMM算法为例，首先导入BreastCancer数据集，参数‘labeled_size’表示有标注数据集的数量(整数)或比例(浮点数)，参数‘stratified’和‘shuffle’分别表示数据集划分时是否需要按类别比划分和是否需要将数据打乱。\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\ndataset=BreastCancer(test_size=0.3,labeled_size=0.1,stratified=True,shuffle=True,random_state=0)\n```\n\n对数据进行预处理。\n\n```python\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n```\n\n调用并初始化SSGMM模型。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.SSGMM import SSGMM\n\nmodel=SSGMM(tolerance=0.000001)\n```\n\n调用fit()方法进行模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n对测试数据进行预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nperformance=Accuracy().scoring(test_y,result)\n```\n\n也可以通过‘predict_proba’方法得到样本属于不同类别的概率。\n\n```python\nscore_y=model.predict_proba(X=test_X)\n```\n\n可以从评估模块调用AUC评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nperformance=AUC(multi_class='ovo').scoring(test_y,pred_y,score_y)\n```\n\n## 训练一个直推式统计半监督分类模型\n\n以TSVM算法为例，首先导入BreastCancer数据集，参数‘labeled_size’表示有标注数据集的数量(整数)或比例(浮点数)，参数‘stratified’和‘shuffle’分别表示数据集划分时是否需要按类别比划分和是否需要将数据打乱。\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\ndataset=BreastCancer(labeled_size=0.1, stratified=True,\nshuffle=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n```\n\n通过sklearn的数据标准化模块对样本进行预处理。\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\n之后导入并初始化TSVM算法，其中参数‘Cl’表示初始状态下有标注样本的权重，参数‘Cu’ 初始状态下无标注样本的权重，参数‘kernel’表示算法中使用的核函数。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.TSVM import TSVM\nmodel=TSVM(Cl=15,Cu=0.0001,kernel='linear')\n```\n\n通过fit()方法就可以完成模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法得到预测结果，由于TSVM为直推式模型，因此predict()方法可以不输入新的数据。\n\n```python\npred_y=model.predict()\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(unlabeled_y,pred_y)\n```\n\n也可以选择将直推式方法拓展为归纳式方法，需要将参数‘Transductive’设置为False。\n\n```python\ntest_X=dataset.test_X\npred_y=model.predict(X=test_X, Transductive=False)\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## 训练一个多视图统计半监督分类模型\n\n以Co-Training算法为例，首先导入BreastCancer数据集，参数‘labeled_size’表示有标注数据集的数量(整数)或比例(浮点数)，参数‘stratified’和‘shuffle’分别表示数据集划分时是否需要按类别比划分和是否需要将数据打乱。\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.BreastCancer import BreastCancer\ndataset=BreastCancer(labeled_size=0.1, stratified=True,\nshuffle=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n```\n\n通过sklearn的数据标准化模块对样本进行预处理。\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\n需要对数据进行多视图划分。\n\n```python\nfrom LAMDA_SSL.Split.ViewSplit import ViewSplit\n\nsplit_labeled_X = ViewSplit(labeled_X, shuffle=False)\nsplit_unlabeled_X = ViewSplit(unlabeled_X, shuffle=False)\nsplit_test_X = ViewSplit(test_X, shuffle=False)\n```\n\n之后导入并初始化Co-Training算法。\n\n```python\nfrom sklearn.svm import SVC\nfrom LAMDA_SSL.Algorithm.Classification.Co_Training import Co_Training\nSVM=SVC(C=1.0,kernel='linear',probability=True,gamma='auto')\nmodel=Co_Training(base_estimator=SVM,s=(len(labeled_X)+len(unlabeled_X))//10)\n```\n\n通过fit()方法就可以完成模型训练，可以将不同视图的数据分别传入。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n也可以以字典或列表形式将不同视图下的数据通过一个参数进行传递。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法得到预测结果。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## 训练一个统计半监督回归模型\n\n以CoReg算法为例，首先导入Boston数据集，参数‘labeled_size’表示有标注数据集的数量(整数)或比例(浮点数)，参数‘stratified’和‘shuffle’分别表示数据集划分时是否需要按类别比划分和是否需要将数据打乱。\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\ndataset=Boston(labeled_size=0.3,test_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n通过sklearn的数据标准化模块对样本进行预处理。\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\n之后导入并初始化CoReg算法。\n\n```python\nfrom LAMDA_SSL.Algorithm.Regression.CoReg import CoReg\nmodel=CoReg()\n```\n\n通过fit()方法就可以完成模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法得到预测结果。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用均方误差评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error\n\nperformance = Mean_Squared_Error().scoring(test_y, pred_y)\n```\n\n## 训练一个统计半监督聚类模型\n\n以Constrained Seed k Means和Constrained k Means算法为例。首先导入Wine数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.Wine import Wine\ndataset = Wine(labeled_size=0.2, stratified=True, shuffle=True,random_state=0,default_transforms=True)\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\nunlabeled_y=dataset.unlabeled_y\n```\n\n通过sklearn的数据标准化模块对样本进行预处理。\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\n```\n\n之后导入并初始化Constrained Seed k Means算法。\n\n```python\nfrom LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means import Constrained_Seed_k_means\n\nmodel = Constrained_Seed_k_means(k=3)\n```\n\n进行模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n也可以导入并初始化Constrained k means算法。\n\n```python\nfrom LAMDA_SSL.Algorithm.Clustering.Constrained_k_means import Constrained_k_means\n\nmodel = Constrained_k_means(k=3)\n```\n\n但对于Constrained k Means算法，其监督信息为必连和勿连约束。如果有用户提供的约束信息，可以直接进行训练。\n\n```python\nmodel.fit(X=X,ml=ml,cl=cl)\n```\n\n如果没有用户提供的约束信息，仅有部分有标注数据，可以利用数据标注构约束信息并进行训练。\n\n```python\nml=[]\ncl=[]\nfor i in range(labeled_X.shape[0]):\n    for j in range(i+1,labeled_X.shape[0]):\n        if labeled_y[i]==labeled_y[j]:\n            ml.append({i,j})\n        else:\n            cl.append({i,j})\nmodel.fit(X=np.vstack((labeled_X,unlabeled_X)), ml=ml,cl=cl)\n```\n\n或是直接以标准接口的形式输入数据，模型内部会自动将有标注数据转化为约束信息。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法得到聚类结果。\n\n```python\npred_y=model.predict()\n```\n\n对于聚类的结果可以使用外部指标或内部指标进行评估，前者的评估需要可参考的聚类结果（如真实标注），如Fowlkes Mallows Score，后者的评估需要样本特征，如Davies Bouldin Score。\n\n```python\nfrom LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score import Fowlkes_Mallows_Score\nfrom LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score import Davies_Bouldin_Score\n\nouter_performence=Fowlkes_Mallows_Score()(y_true=np.hstack([labeled_y, unlabeled_y]),clusters=pred_y)\n\ninner_performence=Davies_Bouldin_Score()(clusters=pred_y,X=np.vstack((labeled_X,unlabeled_X)))\n```\n\n## 训练一个默认配置的深度半监督模型\n\n以FixMatch算法为例。首先导入并初始化CIFAR10数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\cifar-10-python',\n                  labeled_size=4000, stratified=False, shuffle=True, download=True)\n```\n\n通过访问封装数据集参数的方法获取数据集中的具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n之后导入并初始化FixMatch算法。其中参数‘threshold’表示选择无标注样本参与无监督损失计算的自信度阈值，参数‘lamda_u’表示无监督损失的权重，参数‘mu’表示每一批次中无标注样本与有标注样本的比例，参数‘T’表示对软标注的锐化温度，参数‘device’表示训练模型的设备。参数‘epoch’、‘num_it_epoch’，‘num_it_total’分别表示模型训练轮次、每一轮次的迭代次数和所有轮次的总迭代次数，三者设置两个即可对另一个进行补全。其余参数与模块采用默认设置。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,mu=7,T=0.5,epoch=1,num_it_epoch=2**20,num_it_total=2**20，device='cuda:0')\n```\n\n通过fit()方法就可以完成模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法就可以完成对测试样本的预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## 训练一个自定义配置的深度半监督模型\n\n对于pytorch中的各个组件，包括Dataset、Sampler、BatchSampler、Dataloader、Network、Optimizer、Scheduler、Parallel等，LAMDA-SSL支持用户根据需求进行灵活替换或自定义。\n\n以FixMatch算法为例。\n首先导入并初始化CIFAR10数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\cifar-10-python',\n                  labeled_size=4000, stratified=False, shuffle=True, download=True)\n```\n\n通过访问封装数据集参数的方法获取数据集中的具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n在pytorch中，所有具体数据需要先被封装在一个Dataset内用于构建Dataloader，Dataset内应包含具体数据、数据变换方式以及索引函数等，但是在模型初始化时具体数据是未知的，直到调用fit()方法传入数据时才能构建完整的Dataset和Dataloader。因此在LAMDA-SSL中，算法初始化时Dataset作为一个深度学习组件仅是一个不包含具体数据的容器，并不需要传入具体数据，在通过fit()方法传入数据后，DeepModelMixin模块会自动构建完整的Dataset。因此用户可以在算法初始化时灵活更换Dataset模块而不受具体数据影响。\n\n```python\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\n\npre_transform = ToImage()\ntransform = Pipeline([('ToTensor', ToTensor(dtype='float',image=True)),\n                      ('Normalization', Normalization(mean=dataset.mean, std=dataset.std))])\nlabeled_dataset = LabeledDataset(pre_transform=pre_transform, transform=transform)\nunlabeled_dataset = UnLabeledDataset(pre_transform=pre_transform, transform=transform)\nvalid_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\ntest_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n```\n\nLAMDA-SSL同样支持用户根据需求选择数据采样方法，可以对训练时的有标注数据和无标注数据进行随机采样，而对验证和测试数据进行序列采样。参数‘replacement’表示是否重复采样，参数‘num_samples’表示总采样数量，无标注数据的采样数量可以不指定，等到算法初始化时确定无标注样本与有标注样本的比例后由DeepModelMixin模块完成处理。\n\n```python\nfrom LAMDA_SSL.Sampler.RandomSampler import RandomSampler\nfrom LAMDA_SSL.Sampler.SequentialSampler import SequentialSampler\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nunlabeled_sampler=RandomSampler(replacement=True)\nvalid_sampler=SequentialSampler()\ntest_sampler=SequentialSampler()\n```\n\n对于习惯使用BatchSampler的用户，LAMDA-SSL同样支持。\n\n```python\nlabeled_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\nlabeled_batchsampler=BatchSampler(batch_size=64,drop_last=True)\n```\n\nDataloader同样可以根据用户需求更换，且并不受数据集、采样器所影响。参数‘batch_size’表示每一批数据量的大小，参数‘num_workers’表示加载数据的子进程数量，参数‘drop_last’表示是否丢弃不足一个batch的数据，无标注数据的‘batch_size’同样可以暂时不指定。\n\n```python\nfrom LAMDA_SSL.Dataloader.LabeledDataloader import LabeledDataLoader\nfrom LAMDA_SSL.Dataloader.UnlabeledDataloader import UnlabeledDataLoader\nlabeled_dataloader=LabeledDataLoader(batch_size=64,num_workers=0,drop_last=True)\nunlabeled_dataloader=UnlabeledDataLoader(num_workers=0,drop_last=True)\nvalid_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\ntest_dataloader=UnlabeledDataLoader(batch_size=64,num_workers=0,drop_last=False)\n```\n\nLAMDA-SSL支持用户根据自身需求更换或自定义神经网络结构，神经网络均由pytorch构建，继承了torch.nn.Module。这里使用了深度为28、宽度因子为2的WideResNet网络作为FixMatch分类器的骨干网络。\n\n```python\nfrom LAMDA_SSL.Network.WideResNet import WideResNet\nnetwork=WideResNet(num_classes=10,depth=28,widen_factor=2,drop_rate=0)\n```\n\nLAMDA-SSL支持用户使用不同的优化器完成深度半监督模型的训练，且不同于pytorch，不需要在优化器初始化时就输入需要优化的模型参数，只需确定优化器的基本信息即可，避免了优化器与网络结构的耦合。\n\n```python\nfrom LAMDA_SSL.Opitimizer.SGD import SGD\noptimizer=SGD(lr=0.03,momentum=0.9,nesterov=True)\n```\n\n调度器也同理，可以不依赖于优化器与网络结构任意更换，所有后续处理过程都由DeepModelMixin在内部完成。\n\n```python\nfrom LAMDA_SSL.Scheduler.CosineAnnealingLR import CosineAnnealingLR\n\nscheduler = CosineAnnealingLR(eta_min=0, T_max=2 ** 20)\n```\n\n对于存在数据增广的算法，用户可以自由更换数据增广流程，以适应不同的任务场景与数据类型，且数据增广与数据变换一样同时支持sklearn的Pipeline机制和pytorch的Compose机制。对于需要多种增广方式的情况，例如FixMatch中的弱增广和强增广，仅需用python中的列表、元组或字典进行传参，算法内部会完成处理。\n\n```python\nfrom LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\n\nweak_augmentation = Pipeline([('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect'))])\nstrong_augmentation = Pipeline([('RandomHorizontalFlip', RandomHorizontalFlip()),\n                                  ('RandomCrop', RandomCrop(padding=0.125, padding_mode='reflect')),\n                                  ('RandAugment', RandAugment(n=2, m=5, num_bins=10, random=True)),\n                                  ('Cutout', Cutout(v=0.5, fill=(127, 127, 127)))])\naugmentation = {\n    'weak_augmentation': weak_augmentation,\n    'strong_augmentation': strong_augmentation\n}\n```\n\n通过上述组件配置，用户可以非常灵活地根据自身需求更换组件和参数，即可组合出符合使用场景的FixMatch算法，使同一算法可以通用于更广泛的应用场景。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,labeled_sampler=labeled_sampler,unlabeled_sampler=unlabeled_sampler,valid_sampler=valid_sampler,test_sampler=test_sampler,labeled_dataloader=labeled_dataloader,unlabeled_dataloader=unlabeled_dataloader,valid_dataloader=valid_dataloader,test_dataloader=test_dataloader,augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,epoch=1,num_it_epoch=2**20,num_it_total=2**20,device='cuda:0',mu=7,T=0.5,weight_decay=5e-4,threshold=0.95,lambda_u=1.0,ema_decay=0.999)\n```\n\n为了简化参数，也可以用TrainDataset、TrainBatchSampler、TrainSampler、TrainDataloader四个训练数据模块代替原先对有标注数据模块与无标注数据模块的分别传参。训练数据模块都包含一个有标注数据模块和一个无标注数据模块，并对二者进行管理和调度。即使是对有标注数据模块与无标注数据模块分别传参，也会由DeepModelMixin自动合并为训练数据模块，这是由于训练数据模块额外具备调整有标注数据与无标注数据之间采样数量和批次大小比例的功能。在半监督学习的大多数场景下，对于有标注数据模块和无标注数据模块除采样数量和批次大小外均保持一致的情况，仅需初始化一个模块即可，且该模块采样数量和批次大小与有标注数据模块保持一致。\n\n```python\ntrain_dataset=TrainDataset(transform=dataset.transform,unlabeled_transform=dataset.unlabeled_transform)\ntrain_batchsampler=BatchSampler(batch_size=64,drop_last=True)\ntrain_sampler=RandomSampler(replacement=True,num_samples=64*(2**20))\ntrain_dataloader=TrainDataLoader(num_workers=0)\n```\n\n对于有标注数据模块和无标注数据模块除采样数量和批次大小外还存在其他不一致的情况，可以通过列表、元组或字典进行参数传递。\n\n```python\ntrain_dataset=TrainDataset(transform=dataset.transform,unlabeled_transform=dataset.unlabeled_transform)\ntrain_batchsampler=BatchSampler(batch_size=100,drop_last=True)\ntrain_sampler={\n    \"Labeled\":RandomSampler(replacement=True,num_samples=540*100),\n    \"Unlabeled\":RandomSampler(replacement=False)\n}\ntrain_dataloader=TrainDataLoader(num_workers=0)\n```\n\n可以通过训练数据模块对模型进行配置，取代原先通过有标注数据模块和无标注数据进行配置的方法。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(train_dataset=train_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,train_sampler=train_sampler,valid_sampler=valid_sampler,test_sampler=test_sampler,train_dataloader=train_dataloader,valid_dataloader=valid_dataloader,test_dataloader=test_dataloader,augmentation=augmentation,network=network,optimizer=optimizer,scheduler=scheduler,epoch=1,num_it_epoch=2**20,num_it_total=2**20,device='cuda:0',mu=7,T=0.5,weight_decay=5e-4,threshold=0.95,lambda_u=1.0,ema_decay=0.999)\n```\n\n通过fit()方法就可以完成模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\nfit()方法支持直接传入完整的有标注数据集和无标注数据集进行训练。\n\n```python\nmodel.fit(X=dataset.labeled_dataset,unlabeled_X=dataset.unlabeled_dataset)\n```\n\nfit()方法也支持直接传入整个完整的训练数据集。\n\n```python\nmodel.fit(X=dataset.train_dataset)\n```\n\n通过predict()方法就可以完成对测试样本的预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\npredict()方法支持直接传入待预测的数据集。\n\n```python\npred_y=model.predict(X=dataset.test_dataset)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## 训练一个深度半监督文本分类模型\n\n以FixMatch算法为例，首先导入并初始化SST2数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Text.SST2 import SST2\ndataset=SST2(root='..\\Download\\SST2',stratified=True,shuffle=True,download=False,length=50,default_transforms=True)\n```\n\n通过访问封装数据集参数的方法获取数据集中的具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n初始化数据处理流程并初始换数据集组件。这里在文本数据的预处理过程中用Tokenizer进行分词，在对文本进行增广后首先调整文本长度，使用Glove词向量，根据词典将单词映射为下标并转换为Tensor形式。\n\n```python\nfrom LAMDA_SSL.Transform.Text.Vocab import Vocab\nfrom LAMDA_SSL.Transform.Text.Tokenizer import Tokenizer\nfrom LAMDA_SSL.Transform.Text.AdjustLength import AdjustLength\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.Text.GloVe import Glove\nfrom sklearn.pipeline import Pipeline\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\n\npre_transform = Tokenizer('basic_english')\nvectors = Glove()\ntransform = Pipeline([('Adjust_length', Adjust_length(length=dataset.length)),\n                      ('Vocab', Vocab(vectors.vec)),\n                      ('ToTensor', ToTensor())])\nlabeled_dataset = LabeledDataset(pre_transform=pre_transform, transform=transform)\n\nunlabeled_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n\nvalid_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n\ntest_dataset = UnlabeledDataset(pre_transform=pre_transform, transform=transform)\n```\n\n定义对于文本数据的弱数据增广和强数据增广。弱数据增广随机交换文本中相邻的单词，参数‘n’表示交换次数。强数据增广以一定概率替换文本中的单词，TF-IDF值越低的单词被替换的概率越大。\n\n```python\nfrom LAMDA_SSL.Augmentation.Text.RandomSwap import RandomSwap\nfrom LAMDA_SSL.Augmentation.Text.TFIDFReplacement import TFIDFReplacement\nweak_augmentation=Random_swap(n=1)\n\nstrong_augmentation=TFIDF_replacement(text=labeled_X,p=0.7)\n\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n```\n\n使用TextRCNN模型作为骨干网络。\n\n```python\nfrom LAMDA_SSL.Network.TextRCNN import TextRCNN\nnetwork=TextRCNN(n_vocab=vectors.vec.vectors.shape[0],embedding_dim=vectors.vec.vectors.shape[1],\n                 pretrained_embeddings=vectors.vec.vectors,len_seq=50,\n                 num_classes=2)\n```\n\n导入并初始化FixMatch算法。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset,augmentation=augmentation,network=network,mu=7,T=0.5,weight_decay=5e-4,threshold=0.95,lambda_u=1.0,epoch=1,num_it_epoch=2**20,device='cuda:0')\n```\n\n通过fit()方法就可以完成模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法就可以完成对测试样本的预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## 训练一个深度半监督回归模型\n\n以PiModelReg算法为例。首先导入Boston数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Tabular.Boston import Boston\ndataset=Boston(test_size=0.3,labeled_size=0.1,stratified=False,shuffle=True,random_state=0,default_transforms=True)\n```\n\n通过访问封装数据集参数的方法获取数据集中的具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n用StandardScaler对数据进行预处理。\n\n```python\nfrom sklearn import preprocessing\npre_transform=preprocessing.StandardScaler()\npre_transform=dataset.pre_transform\npre_transform.fit(np.vstack([labeled_X, unlabeled_X]))\nlabeled_X=pre_transform.transform(labeled_X)\nunlabeled_X=pre_transform.transform(unlabeled_X)\ntest_X=pre_transform.transform(test_X)\n```\n\n初始化数据处理流程并初始换数据集组件。\n\n```python\nfrom LAMDA_SSL.Dataset.LabeledDataset import LabeledDataset\nfrom LAMDA_SSL.Dataset.UnlabeledDataset import UnlabeledDataset\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\ntransform=ToTensor()\nlabeled_dataset=LabeledDataset(transform=transform)\n\nunlabeled_dataset=UnlabeledDataset(transform=transform)\n\nvalid_dataset=UnlabeledDataset(transform=transform)\n\ntest_dataset=UnlabeledDataset(transform=transform)\n```\n\n以高斯噪声作为数据增广方法。\n\n```python\nfrom LAMDA_SSL.Augmentation.Tabular.Noise import Noise\n\naugmentation = Noise(noise_level=0.01)\n```\n\n将多层感知机作为骨干神经网络。\n\n```python\nnetwork=MLP_Reg(hidden_dim=[100,50,10],activations=[nn.ReLU(),nn.ReLU(),nn.ReLU()],dim_in=labeled_X.shape[-1])\n```\n\n导入并初始化PiModelReg算法。\n\n```python\nmodel=PiModelReg(labeled_dataset=labeled_dataset,\n                unlabeled_dataset=unlabeled_dataset,\n                valid_dataset=valid_dataset,\n                test_dataset=test_dataset,\n                augmentation=augmentation,\n                network=network,lambda_u=0.1,\n                warmup=0.4,mu=1,weight_decay=5e-4,\n                epoch=1,num_it_epoch=4000,device='cuda:0')\n```\n\n通过fit()方法就可以完成模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n通过predict()方法就可以完成对测试样本的预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用均方误差指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error import Mean_Squared_Error \nscore=Mean_Squared_Error().scoring(test_y,pred_y)\n```\n\n## 训练一个深度生成式模型\n\n以ImprovedGAN算法为例，首先导入MNIST数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.Mnist import Mnist\ndataset=Mnist(root='..\\Download\\mnist',labeled_size=6000,shuffle=True,download=False,random_state=0,default_transforms=True)\n```\n\n通过访问数据集属性获取具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\nvalid_X=dataset.valid_X\nvalid_y=dataset.valid_y\n```\n\n导入并初始化ImprovedGAN模型。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.ImprovedGAN import ImprovedGAN\nImprovedGAN=ImprovedGAN(lambda_u=1,dim_z=100,dim_in=(28,28),mu=1,epoch=100,num_it_epoch=540,num_it_total=540*100,device='cuda:0')\n```\n\n对模型进行训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n对测试数据进行预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n与其他深度半监督学习方法相比，深度生成式方法可以通过调用generate()进行数据生成。\n\n```python\nfake_X=model.generate(100)\n```\n\n## 训练一个深度图模型\n\nLAMDA-SSL中的图数据使用了torch_geometric工具包中的torch_geometric.data.data类进行封装。该类中包含了图的结点特征、结点标注、结点间的边等信息，图数据中结点有无标注、用于训练、验证还是测试的都会通过mask的形式进行标记。以GCN算法为例，首先导入并初始化Cora数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Graph.Cora import Cora\ndataset=Cora(labeled_size=0.2,root='..\\Download\\Cora',random_state=0,default_transforms=True)\n```\n\n获取图数据并对数据进行初始化。\n\n```python\nfrom LAMDA_SSL.Transform.Graph.NormalizeFeatures import NormalizeFeatures\n\ntransform = NormalizeFeatures\ndata = dataset.transform.fit_transform(dataset.data)\n```\n\n设置优化器。\n\n```python\nfrom LAMDA_SSL.Opitimizer.Adam import Adam\noptimizer=Adam(lr=0.01)\n```\n\n导入并初始化GCN模型。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.GCN import GCN\nmodel=GCN(num_features=1433,\n          normalize=True,\n          epoch=2000,\n          weight_decay=5e-4,\n          optimizer=optimizer)\n```\n\n对模型进行训练，可以直接输入封装好的图数据。\n\n```python\nmodel.fit(X=data)\n```\n\nfit()方法也支持对图中的各类信息分开传参，算法会自动完成对图数据的封装。\n\n```python\nmodel.fit(X=data.X,y=data.y,edge_index=data.edge_index,\n          labeled_mask=data.labeled_mask,\n          unlabeled_mask=data.unlabeled_mask,val_mask=data.val_mask,\n          test_mask=data.test_mask)\n```\n\n通过predict()方法完成预测。对于封装后具备test_mask属性的图数据不再需要传递新的参数。\n\n```python\npred_y=model.predict()\n```\n\n对于封装后不具备test_mask属性的图数据或需要重新指定待预测结点的情况，可以输入测试结点的mask。\n\n```python\npred_y=model.predict(X=data.test_mask)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(data.y[data.test_mask],pred_y)\n```\n\n## 训练一个分布式深度半监督模型\n\n以FixMatch算法为例，首先导入并初始化CIFAR10数据集。\n\n```python\nfrom LAMDA_SSL.Dataset.Vision.CIFAR10 import CIFAR10\n\ndataset = CIFAR10(root='..\\Download\\cifar-10-python',\n                  labeled_size=4000, stratified=False, shuffle=True, download=True)\n```\n\n通过访问封装数据集参数的方法获取数据集中的具体数据。\n\n```python\nlabeled_X=dataset.labeled_X\nlabeled_y=dataset.labeled_y\nunlabeled_X=dataset.unlabeled_X\ntest_X=dataset.test_X\ntest_y=dataset.test_y\n```\n\n之后导入DataParallel模块。以单机多卡为例，其中参数‘device_ids’表示可用的GPU设备，参数‘output_device’表示模型输出结果存放的GPU设备。\n\n```python\nfrom LAMDA_SSL.Distributed.DataParallel import DataParallel\nparallel=DataParallel(device_ids=['cuda:0','cuda:1'],output_device='cuda:0')\n```\n\n之后导入并初始化FixMatch算法并设置parallel模块。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,mu=7,T=0.5,device='cuda:0',parallel=parallel)\n```\n\n通过predict()方法完成预测。\n\n```python\npred_y=model.predict(X=test_X)\n```\n\n最后可以从评估模块调用准确率评估指标对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n## 模型评估\n\nLAMDA-SSL支持在预测结束后对利用预测结果对模型表现进行评估。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\npred_y=model.predict(X=test_X)\nscore=Accuracy().scoring(test_y,pred_y)\n```\n\n也可以将评估指标作为模型的参数，这样可以用元组、列表或字典存储多个评估指标。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nevaluation={\n    'Accuracy':Accuracy(),\n    'Top_5_Accuracy':Top_k_Accurary(k=5),\n    'Precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_Matrix':Confusion_Matrix(normalize='true')\n}\n```\n\n初始化包含评估模块的模型。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,ema_decay=0.999,device='cuda:0',evaluation=evaluation)\n```\n\n通过fit()方法进行模型训练。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n直接通过模型的evaluate()方法在完成预测的同时进行模型评估，最终返回以元组、列表或字典为形式的评估结果，形式与模型的evaluation模块对应。\n\n```python\nperformance=model.evaluate(X=test_X,y=test_y)\n```\n\nevaluate()方法同样支持直接输入完整的数据集。\n\n```python\nperformance=model.evaluate(X=dataset.test_dataset)\n```\n\n通过访问y_pred属性可以获得预测结果。\n\n```python\ny_pred=model.y_pred\n```\n\n## 模型验证\n\n对于深度半监督学习模型，LAMDA-SSL支持在模型的训练过程中进行验证。\n\n```python\nfrom LAMDA_SSL.Evaluation.Classifier.Accuracy import Accuracy\nfrom LAMDA_SSL.Evaluation.Classifier.Top_k_Accuracy import Top_k_Accurary\nfrom LAMDA_SSL.Evaluation.Classifier.Precision import Precision\nfrom LAMDA_SSL.Evaluation.Classifier.Recall import Recall\nfrom LAMDA_SSL.Evaluation.Classifier.F1 import F1\nfrom LAMDA_SSL.Evaluation.Classifier.AUC import AUC\nfrom LAMDA_SSL.Evaluation.Classifier.Confusion_Matrix import Confusion_Matrix\n\nevaluation={\n    'Accuracy':Accuracy(),\n    'Top_5_Accuracy':Top_k_Accurary(k=5),\n    'Precision':Precision(average='macro'),\n    'Recall':Recall(average='macro'),\n    'F1':F1(average='macro'),\n    'AUC':AUC(multi_class='ovo'),\n    'Confusion_matrix':Confusion_matrix(normalize='true')\n}\n```\n\n初始化含有评估模块的深度半监督模型，并且可以设置‘eval_epoch’参数，每经过‘eval_epoch’个epoch会进行模型验证。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,  ema_decay=0.999,weight_decay=5e-4,epoch=100,num_it_epoch=1000,num_it_total=100*1000,eval_epoch=10,device='cuda:0',evaluation=evaluation)\n```\n\n也可以设置‘eval_it’参数，每经过‘eval_it’次迭代会进行模型验证\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,  ema_decay=0.999,weight_decay=5e-4,epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cuda:0',evaluation=evaluation)\n```\n\n在调用fit()方法是同时输入验证数据可以完成在训练过程中对模型的验证。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X,valid_X=valid_X,valid_y=valid_y)\n```\n\n也可以直接输入完整的验证数据集。\n\n```python\nmodel.fit(X=dataset.labeled_dataset,unlabeled_X=dataset.unlabeled_dataset,valid_X=dataset.valid_dataset)\n```\n\n针对深度图模型，可以以掩码的形式指定需要验证结点。\n\n```python\nmodel.fit(data,valid_X=data.val_mask)\n```\n\n可以访问valid_performance参数获得验证结果。\n\n```python\nvalid_result=model.valid_performance\n```\n\n如果需要在模型训练过程中对验证结果进行实时追踪，可以在模型初始化时设置‘verbose’参数为True，将验证结果实时输出，且可以设置参数‘file’完成输出重定向。\n\n```python\nfile = open(\"../Result/ImprovedGAN_MNIST.txt\", \"w\")\nmodel=FixMatch(threshold=0.95,lambda_u=1.0,T=0.5,mu=7,  ema_decay=0.999,weight_decay=5e-4,epoch=1,num_it_epoch=2**20,num_it_total=2**20,eval_it=2000,device='cuda:0',evaluation=evaluation,verbose=True,file=file)\n```\n\n## 参数搜索\n\nLAMDA-SSL支持sklearn中的参数搜索机制。\n首先初始化一个参数不完整的模型。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nmodel=Fixmatch(train_dataset=train_dataset,test_dataset=test_dataset,\n               train_dataloader=train_dataloader,test_dataloader=test_dataloader,\n               augmentation=augmentation,network=network,epoch=1,num_it_epoch=2,num_it_total=2,\n               optimizer=optimizer,scheduler=scheduler,device='cpu',eval_it=1,\n               mu=7,T=1,weight_decay=0,evaluation=evaluation,train_sampler=train_sampler,\n               test_sampler=test_sampler,train_batch_sampler=train_batchsampler,ema_decay=0.999)\n```\n\n以字典的形式设置待搜索参数。\n\n```python\nparam_dict = {\"threshold\": [0.7, 1],\n              \"lambda_u\":[0.8, 1]\n              }\n```\n\n以随机搜索的方式进行参数搜索。\n首先进行搜索方式初始化。\n\n```python\nfrom sklearn.model_selection import RandomizedSearchCV\nrandom_search = RandomizedSearchCV(model, param_distributions=param_dict,n_iter=1, cv=4,scoring='accuracy')\n```\n\n开始参数搜索过程。\n\n```python\nrandom_search.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n最终通过‘best_params_’参数获得搜索结果。\n\n```python\nbest_params=random_search.best_params_\n```\n\n## 保存和加载模型\n\n可以使用pickle保存和加载半监督学习模型。\n设置路径。\n\n```python\npath='../save/FixMatch.pkl'\n```\n\n保存模型。\n\n```python\nwith open(path, 'wb') as f:\n    pickle.dump(model, f)\n```\n\n加载模型。\n\n```python\nwith open(path, 'rb') as f:\n    model = pickle.load(f)\n```\n\n## 自定义数据\n\n除了LAMDA-SSL提供的数据集，用户可以非常方便地使用自己的数据集。在需要对数据集进行划分时都可以调用LAMDA-SSL中Split模块的Data_Split函数。\n\n```python\nfrom LAMDA_SSL.Split.DataSplit import DataSplit\n\nlabeled_X, labeled_y, unlabeled_X, unlabeled_y = DataSplit(X=X, y=y, size_split=self.labeled_size,\n                                                            stratified=self.stratified, shuffle=self.shuffle,\n                                                            random_state=self.random_state)\n```\n\n在统计半监督学习算法中，直接将预处理过后的数据传入fit()方法即可。\n\n```python\nmodel.fit(X=labeled_X,y=labeled_y,unlabeled_X=unlabeled_X)\n```\n\n在深度半监督学习算法中，在不需要数据增广的情况下，同样可以直接将预处理过后的数据传入fit()，也可以通过设置dataset中的pre_transform、transform、transforms、target_transform等参数指定数据处理方式，这样就可以在数据被加载时再进行相应的处理。其中transforms表示对X和y同时进行处理的处理方式，target_transform表示对y进行处理的处理方式，pre_transform、transform分别表示在数据增广前后分别需要对数据进行处理的处理方式。如对于CIFAR10数据集，其原始数据为numpy.ndarray格式，需要在数据增广前转化为图片格式，对图片进行增广后需要转化为torch.Tensor格式并进行归一化。\n\n```python\nfrom LAMDA_SSL.Transform.Vision.Normalization import Normalization\nfrom LAMDA_SSL.Transform.ToTensor import ToTensor\nfrom LAMDA_SSL.Transform.ToImage import ToImage\ntransforms=None\ntarget_transform=None\npre_transform=ToImage()\ntransform=Pipeline([('ToTensor',ImageToTensor()),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\nunlabeled_transform=Pipeline([('ToTensor',ImageToTensor()),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\ntest_transform=Pipeline([('ToTensor',ImageToTensor()),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\nvalid_transform=Pipeline([('ToTensor',ImageToTensor()),\n                        ('Normalization',Normalization(mean=dataset.mean,std=dataset.std))\n                        ])\n```\n\n用户可以将自定义的数据转换方式传入数据集模块，作为深度学习中的组件，模型在学习过程中会对原始数据进行加载和处理。\n\n```python\nlabeled_dataset=LabeledDataset(pre_transform=dataset.pre_transform,transforms=dataset.transforms,\n                               transform=dataset.transform,target_transform=dataset.target_transform)\nunlabeled_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.unlabeled_transform)\nvalid_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.valid_transform)\ntest_dataset=UnlabeledDataset(pre_transform=dataset.pre_transform,transform=dataset.test_transform)\n\nmodel=FixMatch(labeled_dataset=labeled_dataset,unlabeled_dataset=unlabeled_dataset,valid_dataset=valid_dataset,test_dataset=test_dataset)\n```\n\n在需要进行数据增广的情况下，用户可以自定义对自身数据的增广方法,对于需要多种增广方式的情况下，可以用元组、列表或字典进行传参。\n\n```python\nfrom LAMDA_SSL.Algorithm.Classification.FixMatch import FixMatch\nfrom LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip import RandomHorizontalFlip\nfrom LAMDA_SSL.Augmentation.Vision.RandomCrop import RandomCrop\nfrom LAMDA_SSL.Augmentation.Vision.RandAugment import RandAugment\nfrom LAMDA_SSL.Augmentation.Vision.Cutout import Cutout\nweak_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ])\n\nstrong_augmentation=Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),\n                              ('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),\n                              ('RandAugment',RandAugment(n=2,m=10,num_bins=10)),\n                              ('Cutout',Cutout(v=0.5,fill=(127, 127, 127))),\n                              ])\naugmentation={\n    'weak_augmentation':weak_augmentation,\n    'strong_augmentation':strong_augmentation\n}\n\nmodel=FixMatch(augmentation=augmentation)\n```\n\n## 自定义数据变换\n\n自定义的数据变换方法需要继承LAMDA_SSL.Transform.Transformer类。与sklearn中的数据变换模块相同，除初始化外仅需实现fit()和transform()两个方法，对于部分不需要fit()过程的变换器，可以将fit()方法省略。以Normalization为例。\n\n```python\nfrom torchvision.transforms import transforms\nfrom LAMDA_SSL.Base.Transformer import Transformer\n\n\nclass Normalization(Transformer):\n    def __init__(self, mean=None, std=None):\n        super().__init__()\n        self.mean = mean\n        self.std = std\n        self.normalize = transforms.Normalize(mean=self.mean, std=self.std)\n\n    def transform(self, X):\n        X = self.normalize(X.float())\n        return X\n```\n\n## 自定义采样器\n\n自定义的采样器需要继承LAMDA_SSL.Sampler.BaseSampler类，需要实现init_sampler()方法，通过输入真实数据集返回一个torch.utils.data.sampler.Sampler对象。以RandomSampler为例。\n\n```python\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nfrom torch.utils.data import sampler\n\n\nclass RandomSampler(BaseSampler):\n    def __init__(self, replacement: bool = False,\n                 num_samples=None, generator=None):\n        super().__init__()\n        self.replacement = replacement\n        self.num_samples = num_samples\n        self.generator = generator\n\n    def init_sampler(self, data_source):\n        return sampler.RandomSampler(data_source=data_source, replacement=self.replacement,num_samples=self.num_samples, generator=self.generator)\n```\n\nLAMDA_SSL支持使用BatchSampler类，需要实现init_sampler()方法，可以将一个torch.utils.data.sampler.Sampler对象转换为一个torch.utils.data.sampler.BatchSampler对象。\n\n```python\nfrom LAMDA_SSL.Base.BaseSampler import BaseSampler\nimport torch.utils.data.sampler as torchsampler\n\n\nclass BatchSampler(BaseSampler):\n    def __init__(self, batch_size: int, drop_last: bool):\n        super().__init__()\n        self.batch_size = batch_size\n        self.drop_last = drop_last\n\n    def init_sampler(self, sampler):\n        return torchsampler.BatchSampler(sampler=sampler, batch_size=self.batch_size, drop_last=self.drop_last)\n```\n\n## 自定义优化器\n\n自定义的采样器需要继承LAMDA_SSL.Optimizer.BaseOptimizer类，并且需要实现init_optimizer()方法，输入待优化的参数，输出一个torch.optim.optimizer.Optimizer对象。以Adam优化器为例。\n\n```python\nfrom LAMDA_SSL.Base.BaseOptimizer import BaseOptimizer\nfrom torch.optim import adam\n\n\nclass Adam(BaseOptimizer):\n    def __init__(self, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, amsgrad=False):\n        self.lr = lr\n        self.betas = betas\n        self.eps = eps\n        self.weight_decay = weight_decay\n        self.amsgrad = amsgrad\n        defaults = dict(lr=lr, betas=betas, eps=eps,\n                        weight_decay=weight_decay, amsgrad=amsgrad)\n        super().__init__(defaults=defaults)\n\n    def init_optimizer(self, params):\n        return adam.Adam(params=params, lr=self.lr, betas=self.betas, eps=self.eps,\n                         weight_decay=self.weight_decay, amsgrad=self.amsgrad)\n\n```\n\n## 自定义学习率调度器\n\n自定义的调度器需要继承BaseScheduler类，\n并且需要实现init_scheduler()方法，输入一个torch.optim.optimizer.Optimizer对象，输出一个torch.optim.lr_scheduler._LRScheduler对象。以StepLR为例。\n\n```python\nfrom torch.optim import lr_scheduler\nfrom LAMDA_SSL.Base.BaseScheduler import BaseScheduler\nclass StepLR(BaseScheduler):\n    def __init__(self,  step_size, gamma=0.1, last_epoch=-1, verbose=False):\n        super().__init__(last_epoch=last_epoch,verbose=verbose)\n        self.step_size=step_size\n        self.gamma=gamma\n        self.last_epoch=last_epoch\n        self.verbose=verbose\n\n    def init_scheduler(self,optimizer):\n        return lr_scheduler.StepLR(optimizer=optimizer,step_size=self.step_size,gamma=self.gamma,last_epoch=self.last_epoch,verbose=self.verbose)\n\n```\n\nLAMDA-SSL支持pytorch中的LambdaLR调度器，需要继承LAMDA_SSL.Scheduler.LambdaLR类，并且需要实现_lr_lambda方法，输入当前步数，返回学习率变动因子。调整规则为$new_{lr}=lambda(current\\_step)\\times initial_{lr}$。以Linear_Warmup为例。\n\n```python\nfrom LAMDA_SSL.Base.LambdaLR import LambdaLR\n\n\nclass Linear_Warmup(LambdaLR):\n    def __init__(self,\n                 num_training_steps,\n                 num_warmup_steps=0,\n                 start_factor=0,\n                 end_factor=1,\n                 last_epoch=-1,\n                 verbose=False):\n        self.start_factor = start_factor\n        self.end_factor = end_factor\n        self.num_warmup_steps = num_warmup_steps\n        self.num_training_steps = num_training_steps\n        self.verbose = verbose\n        super().__init__(lr_lambda=self._lr_lambda, last_epoch=last_epoch, verbose=self.verbose)\n\n    def _lr_lambda(self, current_step):\n        if current_step > self.num_warmup_steps:\n            return self.start_factor + float(self.num_training_steps - current_step)\n            / (self.num_training_steps - self.num_warmup_steps) * (self.end_factor - self.start_factor)\n        return 1\n```\n\n## 自定义损失函数\n\nLAMDA-SSL实现的损失函数都继承了torch.nn.Module模块，需要实现forward()方法，返回损失函数的计算结果。\n\n```python\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch\n\nclass Consistency(nn.Module):\n    def __init__(self,reduction='mean'):\n        super().__init__()\n        self.reduction = reduction\n\n    def forward(self,logits_1,logits_2):\n        assert logits_1.size() == logits_2.size()\n        return F.mse_loss(torch.softmax(logits_1, dim=-1), torch.softmax(logits_2, dim=-1), reduction='mean')\n```\n\n## 自定义评估指标\n\n自定义的分类评估指标需要继承LAMDA_SSL.Evaluation.Classification.EvaluationClassification中的EvaluationClassification。需要实现scoring方法，输入真实标记，模型预测的硬标记或软标记进行打分。以准确率指标为例。\n\n```python\nfrom LAMDA_SSL.Base.ClassifierEvaluation import ClassifierEvaluation\nfrom sklearn.metrics import accuracy_score\nfrom LAMDA_SSL.utils import partial\n\n\nclass Accuracy(ClassifierEvaluation):\n    def __init__(self, normalize=True, sample_weight=None):\n        super().__init__()\n        self.normalize = normalize\n        self.sample_weight = sample_weight\n        self.score = partial(accuracy_score, normalize=self.normalize, sample_weight=self.sample_weight)\n\n    def scoring(self, y_true, y_pred=None, y_score=None):\n        return self.score(y_true=y_true, y_pred=y_pred)\n```\n\n自定义的分类评估指标需要继承LAMDA_SSL.Base.RegressorEvaluation中的RegressorEvaluation。需要实现scoring方法，输入真实标记和模型预测结果进行打分。以均方误差损失为例。\n\n```python\nfrom LAMDA_SSL.Baes.RegressorEvaluation import RegressorEvaluation\nfrom sklearn.metrics import mean_squared_error\nfrom LAMDA_SSL.utils import partial\n\nclass Mean_Squared_Error(RegressorEvaluation):\n    def __init__(self,sample_weight=None, multioutput=\"uniform_average\",squared=True):\n        super().__init__()\n        self.sample_weight=sample_weight\n        self.multioutput=multioutput\n        self.squared=squared\n        self.score=partial(mean_squared_error,sample_weight=self.sample_weight,\n                           multioutput=self.multioutput,squared=squared)\n    def scoring(self,y_true,y_pred=None):\n        return self.score(y_true=y_true,y_pred=y_pred)\n```\n\n自定义的聚类评估指标需要继承LAMDA_SSL.Evaluation.Cluster.EvaluationCluster中的EvaluationCluster。需要实现scoring方法，输入真实标记、聚类结果和样本特征进行打分。以Davies_Bouldin指标为例。\n\n```python\nfrom LAMDA_SSL.Base.ClusterEvaluation import ClusterEvaluation\nfrom sklearn.metrics import davies_bouldin_score\nclass Davies_Bouldin_Score(ClusterEvaluation):\n    def __init__(self):\n        super().__init__()\n        self.score=davies_bouldin_score\n\n    def scoring(self,y_true=None,clusters=None,X=None):\n        return self.score(labels=clusters,X=X)\n```\n\n## 自定义统计半监督学习算法\n\n用户可以通过LAMDA-SSL自定义新的半监督学习算法，可以通过组合LAMDA-SSL中的InductiveEstimator、TransductiveEstimator、DeepModelMixin等模块和sklearn中的ClassifierMixin、RegressorMixin、ClusterMixin等模块构建自定义的学习器，可以继承各模块对应的功能。\n\n对于统计半监督学习算法，直接实现fit()方法和predict()方法即可，也可以进一步实现predict_proba()方法获取模型预测的软标注。以SSGMM算法为例。\n\n```python\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom sklearn.base import ClassifierMixin\nimport numpy as np\nfrom LAMDA_SSL.utils import class_status\nimport LAMDA_SSL.Config.SSGMM as config\n\nclass SSGMM(InductiveEstimator,ClassifierMixin):\n    def __init__(self,tolerance=config.tolerance, max_iterations=config.max_iterations, num_classes=config.num_classes,\n                 evaluation=config.evaluation,verbose=config.verbose,file=config.file):\n        self.num_classes=num_classes\n        self.tolerance=tolerance\n        self.max_iterations=max_iterations\n        self.evaluation = evaluation\n        self.verbose = verbose\n        self.file = file\n        self.y_pred=None\n        self.y_score=None\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def normfun(self,x, mu, sigma):\n        k = len(x)\n        dis = np.expand_dims(x - mu, axis=0)\n        pdf = np.exp(-0.5 * dis.dot(np.linalg.inv(sigma)).dot(dis.T)) / np.sqrt(\n            ((2 * np.pi) ** k) * np.linalg.det(sigma))\n        return pdf\n\n    def fit(self,X,y,unlabeled_X):\n        self.num_classes = self.num_classes if self.num_classes is not None else \\\n            class_status(y).num_classes\n        L=len(X)\n        U=len(unlabeled_X)\n        m=L+U\n        labele_set={}\n        for _ in range(self.num_classes):\n            labele_set[_]=set()\n        for _ in range(L):\n            labele_set[y[_]].add(_)\n        self.mu=[]\n        self.alpha=[]\n        self.gamma=np.empty((U,self.num_classes))\n        self.alpha = np.random.rand(self.num_classes)\n        self.alpha = self.alpha / self.alpha.sum()\n        self.mu = np.random.rand(self.num_classes, X.shape[1])\n        self.sigma = np.empty((self.num_classes, X.shape[1], X.shape[1]))\n        for i in range(self.num_classes):\n            self.sigma[i] = np.eye(X.shape[1])\n        for _ in range(self.max_iterations):\n            # E Step\n            pre=copy.copy(self.alpha)\n            for j in range(U):\n                _sum=0\n                for i in range(self.num_classes):\n                    _sum+=self.alpha[i]*self.normfun(unlabeled_X[j],self.mu[i],self.sigma[i])\n                for i in range(self.num_classes):\n                    self.gamma[j][i]=self.alpha[i]*self.normfun(unlabeled_X[j],self.mu[i],self.sigma[i])/_sum\n            # M step\n            for i in range(self.num_classes):\n                _sum_mu=0\n                _sum_sigma=np.zeros((X.shape[1],X.shape[1]))\n                _norm=0\n                _norm+=len(labele_set[i])\n                for j in labele_set[i]:\n                    _sum_mu+=X[j]\n                for j in range(U):\n                    _sum_mu+=self.gamma[j][i]*unlabeled_X[j]\n                    _norm+=self.gamma[j][i]\n                self.mu[i]=_sum_mu/_norm\n                self.alpha[i]=_norm/m\n                for j in labele_set[i]:\n                    _sum_sigma+=np.outer(X[j]-self.mu[i],X[j]-self.mu[i])\n                for j in range(U):\n                    _sum_sigma += self.gamma[j][i]*np.outer(unlabeled_X[j] - self.mu[i], unlabeled_X[j] - self.mu[i])\n                self.sigma[i]=_sum_sigma/_norm\n            isOptimal = True\n            for i in range(self.num_classes):\n                if abs((self.alpha[i] - pre[i])/pre[i])>self.tolerance:\n                    isOptimal=False\n            if isOptimal:\n                break\n        return self\n\n    def predict_proba(self,X):\n        y_proba=np.empty((len(X),self.num_classes))\n        for i in range(len(X)):\n            _sum=0\n            for j in range(self.num_classes):\n                _sum+=self.normfun(X[i],self.mu[j],self.sigma[j])\n            for j in range(self.num_classes):\n                y_proba[i][j]=self.normfun(X[i],self.mu[j],self.sigma[j])/_sum\n        return y_proba\n\n    def predict(self,X):\n        y_proba=self.predict_proba(X)\n        y_pred=np.argmax(y_proba, axis=1)\n        return y_pred\n```\n\n## 自定义深度半监督学习算法\n\n对于深度半监督学习模型，用户可以自己实现fit()方法和predict()方法，但是这过于繁琐，可以通过直接继承DeepModelMixin简化很多重复操作。DeepModelMixin模块对深度学习模型的训练和预测过程进行了细分，并对于每一细分过程提供了默认的处理放式，用户只需替换变动的部分就可以用少量代码完成对算法的自定义。\n\n\ninit_model()方法需要完成神经网络初始化，包括在必要时将网络放在指定设备上或进行分布式处理。\n\n```python\ndef init_model(self):\n    if self.device is not None and self.device is not 'cpu':\n        torch.cuda.set_device(self.device)\n    self._network=self._network.to(self.device)\n    if self._parallel is not None:\n        self._network=self._parallel.init_parallel(self._network)\n```\n\ninit_ema()方法主要针对需要对模型参数使用指数移动平滑机制的情况，当'ema_decay'参数不为None时会初始化一个EMA模型。\n\n```python\ndef init_ema(self):\n    if self.ema_decay is not None:\n        self.ema=EMA(model=self._network,decay=self.ema_decay)\n        self.ema.register()\n    else:\n        self.ema=None\n```\n\ninit_optimizer()方法会对模型训练中使用的优化器进行初始化，在此过程中会为优化器指定待优化的模型参数。\n\n```python\ndef init_optimizer(self):\n    if isinstance(self._optimizer,BaseOptimizer):\n        no_decay = ['bias', 'bn']\n        grouped_parameters = [\n            {'params': [p for n, p in self._network.named_parameters() if not any(\n                nd in n for nd in no_decay)], 'weight_decay': self.weight_decay},\n            {'params': [p for n, p in self._network.named_parameters() if any(\n                nd in n for nd in no_decay)], 'weight_decay': 0.0}\n        ]\n        self._optimizer=self._optimizer.init_optimizer(params=grouped_parameters)\n```\n\ninit_scheduler()方法会对模型训练中使用的学习率调度器进行初始化，在此过程中会为调度器指定待需要进行调度的优化器。\n\n```python\ndef init_scheduler(self):\n    if isinstance(self._scheduler,BaseScheduler):\n        self._scheduler=self._scheduler.init_scheduler(optimizer=self._optimizer)\n```\n\ninit_epoch()方法会对模型的epoch、num_it_epoch、num_it_total三个参数进行自适应补全。\n\n```python\ndef init_epoch(self):\n    if self.num_it_epoch is not None and self.epoch is not None:\n        self.num_it_total=self.epoch*self.num_it_epoch\n    elif self.num_it_total is not None and self.epoch is not None:\n        self.num_it_epoch=ceil(self.num_it_total/self.epoch)\n    elif self.num_it_total is not None and self.num_it_epoch is not None:\n        self.epoch=ceil(self.num_it_total/self.num_it_epoch)\n```\n\ninit_augmentation()方法会对模型的增广方式进行初始化。\n\n```python\ndef init_augmentation(self):\n    if self._augmentation is not None:\n        if isinstance(self._augmentation, dict):\n            self.weak_augmentation = self._augmentation['augmentation'] \\\n                if 'augmentation' in self._augmentation.keys() \\\n                else self._augmentation['weak_augmentation']\n            if 'strong_augmentation' in self._augmentation.keys():\n                self.strong_augmentation = self._augmentation['strong_augmentation']\n        elif isinstance(self._augmentation, (list, tuple)):\n            self.weak_augmentation = self._augmentation[0]\n            if len(self._augmentation) > 1:\n                self.strong_augmentation = self._augmentation[1]\n        else:\n            self.weak_augmentation = copy.deepcopy(self._augmentation)\n        if self.strong_augmentation is None:\n            self.strong_augmentation = copy.deepcopy(self.weak_augmentation)\n```\n\ninit_transform()方法会对数据的变换方法进行初始化，会将数据增广加入到数据的处理流程当中。add_transform()方法表示对有标注样本增加新的处理方式。可以将LAMDA-SSL的数据处理视为一个二维列表，dim=0时表示增加横向数据处理，即在原先数据处理的基础上增加一项新的独立的数据处理流程，会使原先数据被多复制一份用于新的流程，处理后得到的数据也会较原先多出一份；dim=1时表示增加纵向数据处理，即将经过原有处理后数据再进行进一步处理，并不会复制数据使数据份数增加，x和y用于表示新加入的数据处理方式在二维列表中的位置。add_unlabeled_transform()方法表示对无标注样本增加新的处理方式，与add_transform()方法同理。\n\n以ICT算法为例，其init_transform()方法的实现为：\n\n```python\ndef init_transform(self):\n    if self.weak_augmentation is not None:\n        self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation, dim=1, x=0, y=0)\n```\n\n原先的有标注数据处理流程和无标注数据处理流程都是：\n\n```python\n[\n    [Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\n在首个数据处理流程的首个位置添加弱数据增广后，有标注数据处理流程和无标注数据处理流程都变为：\n\n```python\n[\n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\n这样在数据加载中数据被依次执行弱增广和原有变换，数据的份数没有增加。\n\n```python\nlb_X = lb_X\nulb_X = ulb_X\n```\n\n再以FixMatch算法为例，其init_transform()方法的实现为：\n\n```python\ndef init_transform(self):\n    self._train_dataset.add_unlabeled_transform(copy.deepcopy(self.train_dataset.unlabeled_transform),dim=0,x=1)\n    self._train_dataset.add_transform(self.weak_augmentation,dim=1,x=0,y=0)\n    self._train_dataset.add_unlabeled_transform(self.weak_augmentation,dim=1,x=0,y=0)\n    self._train_dataset.add_unlabeled_transform(self.strong_augmentation,dim=1,x=1,y=0)\n```\n\n原先的有标注数据处理和无标注数据处理流程都是：\n\n```python\n[\n    [Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nFixMatch算法对有标注数据的首个数据处理流程增加了弱数据增广。其数据处理流程变为：\n\n```python\n[\n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\nFixMatch算法对无标注数据的首个数据处理流程进行了复制，形成了两个数据独立的处理流程，并分别增加了弱数据增广和强数据增广。其数据处理流程变为：\n\n```python\n[\n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])],\n    \n    [Pipeline([('RandomHorizontalFlip',RandomHorizontalFlip()),('RandomCrop',RandomCrop(padding=0.125,padding_mode='reflect')),('RandAugment',RandAugment(n=2,m=10,num_bins=10)),('Cutout',Cutout(v=0.5,fill=(127, 127, 127)))]), \n    Pipeline([('ToTensor',ImageToTensor()),('Normalization',Normalization(mean=dataset.mean,std=dataset.std))])]\n]\n```\n\n这样在数据加载中无标注数据的份数发生了增加。\n\n```python\nlb_X = lb_X\nw_ulb_X, s_ulb_X = ulb_X[0], ulb_X[1]\n```\n\nDeepModelMixin的fit()方法包含了5个部分：init_train_dataset()、init_train_dataloader()、start_fit()、fit_epoch_loop()、end_fit()。\n\n```python\ndef fit(self,X=None,y=None,unlabeled_X=None,valid_X=None,valid_y=None):\n    self.init_train_dataset(X,y,unlabeled_X)\n    self.init_train_dataloader()\n    self.start_fit()\n    self.fit_epoch_loop(valid_X,valid_y)\n    self.end_fit()\n    return self\n```\n\ninit_train_dataset()方法对fit()方法输入的数据进行封装处理。最终获得一个封装好的训练数据集。\n\n```python\ndef init_train_dataset(self,X=None,y=None,unlabeled_X=None, *args, **kwargs):\n    if isinstance(X,TrainDataset):\n        self._train_dataset=X\n    elif isinstance(X,Dataset) and y is None:\n        self._train_dataset.init_dataset(labeled_dataset=X, unlabeled_dataset=unlabeled_X)\n    else:\n        self._train_dataset.init_dataset(labeled_X=X, labeled_y=y,unlabeled_X=unlabeled_X)\n```\n\ninit_train_dataloader()方法根据训练数据集、训练数据采样器、每一批次无标注数据与有标注数据的比例获得完整的数据加载器。\n\n```python\ndef init_train_dataloader(self):\n    if self._train_dataloader is not None:\n        self._labeled_dataloader,self._unlabeled_dataloader=self._train_dataloader.init_dataloader(dataset=self._train_dataset,\n                                                                                    sampler=self._train_sampler,\n                                                                                    batch_sampler=self._train_batch_sampler,\n                                                                                    mu=self.mu)\n    else:\n        self._train_dataloader=TrainDataLoader(labeled_dataloader=self._labeled_dataloader,unlabeled_dataloader=self._unlabeled_dataloader)\n        self._train_sampler={'labeled':self._labeled_sampler,'unlabeled':self._unlabeled_sampler}\n        self._train_batch_sampler={'labeled':self._labeled_batch_sampler,'unlabeled':self._unlabeled_batch_sampler}\n        self._labeled_dataloader, self._unlabeled_dataloader = self._train_dataloader.init_dataloader(\n            dataset=self._train_dataset,\n            sampler=self._train_sampler,\n            batch_sampler=self._train_batch_sampler,\n            mu=self.mu)\n```\n\nstart()方法为深度学习在通过迭代进行训练前需要完成的操作。\n\n```python\ndef start_fit(self, *args, **kwargs):\n    self._network.zero_grad()\n    self._network.train()\n```\n\nfit_epoch_loop()方法为模型迭代训练的过程，并且需要在满足条件的情况下对模型表现进行验证。该方法实现了对于每一轮次的外部循环，对同一轮次的内部训练过程又可以分为三部分：start_fit_epoch()、fit_batch_loop()、end_fit_epoch()。\n\n```python\ndef fit_epoch_loop(self,valid_X=None,valid_y=None):\n    self.valid_performance={}\n    self.it_total = 0\n    for self._epoch in range(1,self.epoch+1):\n        self.it_epoch=0\n        if self.it_total >= self.num_it_total:\n            break\n        self.start_fit_epoch()\n        self.fit_batch_loop(valid_X,valid_y)\n        self.end_fit_epoch()\n        if valid_X is not None and self.eval_epoch is not None and self._epoch % self.eval_epoch==0:\n            self.evaluate(X=valid_X,y=valid_y,valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n\n    if valid_X is not None and self.epoch%self.eval_epoch!=0:\n        self.evaluate(X=valid_X, y=valid_y, valid=True)\n        self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n```\n\nstart_fit_epoch()方法为在每一epoch训练开始前需要进行的操作，DeepModelMixin默认没有任何操作，可以根据算法需求进行添加。\n\n```python\ndef start_fit_epoch(self, *args, **kwargs):\n    pass\n```\n\nfit_batch_loop()方法为每一轮次训练的内部循环，循环的每一步处理一个Batch的数据，并在满足条件时对模型进行验证。其内部还包含了start_fit_batch()、train()、end_fit_batch()三个方法。\n\n```python\ndef fit_batch_loop(self,valid_X=None,valid_y=None):\n    for (lb_idx, lb_X, lb_y), (ulb_idx, ulb_X, _) in zip(self._labeled_dataloader, self._unlabeled_dataloader):\n        if self.it_epoch >= self.num_it_epoch or self.it_total >= self.num_it_total:\n            break\n        self.start_fit_batch()\n        lb_idx = to_device(lb_idx,self.device)\n        lb_X = to_device(lb_X,self.device)\n        lb_y = to_device(lb_y,self.device)\n        ulb_idx = to_device(ulb_idx,self.device)\n        ulb_X  = to_device(ulb_X,self.device)\n        train_result = self.train(lb_X=lb_X, lb_y=lb_y, ulb_X=ulb_X, lb_idx=lb_idx, ulb_idx=ulb_idx)\n        self.end_fit_batch(train_result)\n        self.it_total += 1\n        self.it_epoch += 1\n        if self.verbose:\n            print(self.it_total,file=self.file)\n        if valid_X is not None and self.eval_it is not None and self.it_total % self.eval_it == 0:\n            self.evaluate(X=valid_X, y=valid_y,valid=True)\n            self.valid_performance.update({\"epoch_\" + str(self._epoch) + \"_it_\" + str(self.it_epoch): self.performance})\n```\n\nstart_fit_batch()是在每一批次训练开始前的操作。DeepModelMixin默认没有任何操作，可以根据算法需求进行添加。\n\n```python\ndef start_fit_batch(self, *args, **kwargs):\n    pass\n```\n\ntrain()方法是对于每一批次数据进行训练的过程，以元组的形式返回训练结果，也是一个所有深度半监督学习算法都应该具备的过程。\n\n```python\ndef train(self,lb_X=None,lb_y=None,ulb_X=None,lb_idx=None,ulb_idx=None,*args,**kwargs):\n    raise NotImplementedError\n```\n\nend_fit_batch()是在每一批次训练结束后的操作，默认包含两个部分：get_loss()和optimize()。\n\n```python\ndef end_fit_batch(self, train_result,*args, **kwargs):\n    self.loss = self.get_loss(train_result)\n    self.optimize(self.loss)\n```\n\nget_loss()是模型根据训练结果计算损失函数的过程，返会loss计算结果，这也是一个所有深度半监督学习算法都应该具备的过程。\n\n```python\ndef get_loss(self,train_result,*args,**kwargs):\n    raise NotImplementedError\n```\n\noptimize()方法是在获得loss后进行反向传播、参数优化和学习率调度的过程。\n\n```python\ndef optimize(self,loss,*args,**kwargs):\n    self._network.zero_grad()\n    loss.backward()\n    self._optimizer.step()\n    if self._scheduler is not None:\n        self._scheduler.step()\n    if self.ema is not None:\n        self.ema.update()\n```\n\nend_fit_epoch()方法是在每一epoch训练结束时需要进行的操作。DeepModelMixin默认没有任何操作，可以根据算法需求进行添加。\n\n```python\ndef end_fit_epoch(self, *args, **kwargs):\n    pass\n```\n\nend_fit()方法是在fit()方法结束时需要进行的操作。DeepModelMixin默认没有任何操作，可以根据算法需求进行添加。\n\n```python\ndef end_fit(self, *args, **kwargs):\n    pass\n```\n\nDeepModelMixin的predict()方法分为了5个部分：init_estimate_dataset()、init_estimate_dataloader()、start_predict()、predict_batch_loop()、end_predict()。\n\n```python\n@torch.no_grad()\ndef predict(self,X=None,valid=False):\n    self.init_estimate_dataset(X,valid)\n    self.init_estimate_dataloader(valid)\n    self.start_predict()\n    self.predict_batch_loop()\n    self.end_predict()\n    return self.y_pred\n```\n\n针对分类任务的predict_proba()方法与predict()方法具有相同的结构，但是返回值不同。\n\n```python\n@torch.no_grad()\ndef predict_proba(self,X=None,valid=False):\n    self.init_estimate_dataset(X,valid)\n    self.init_estimate_dataloader(valid)\n    self.start_predict()\n    self.predict_batch_loop()\n    self.end_predict()\n    return self.y_score\n```\n\ninit_estimate_dataset()方法需要对待估计的数据进行封装，最终形成一个完整的数据集\n\n```python\ndef init_estimate_dataset(self, X=None,valid=False):\n    if valid:\n        if isinstance(X,Dataset):\n            self._valid_dataset=X\n        else:\n            self._valid_dataset=self._valid_dataset.init_dataset(X=X)\n    else:\n        if isinstance(X,Dataset):\n            self._test_dataset=X\n        else:\n            self._test_dataset=self._test_dataset.init_dataset(X=X)\n```\n\ninit_estimate_dataloader()方法根据估计数据集和估计采样器获得用于估计的数据加载器。\n\n```python\ndef init_estimate_dataloader(self,valid=False):\n    if valid:\n        self._estimate_dataloader=self._valid_dataloader.init_dataloader(self._valid_dataset,sampler=self._valid_sampler,batch_sampler=self._valid_batch_sampler)\n    else:\n        self._estimate_dataloader=self._test_dataloader.init_dataloader(self._test_dataset,sampler=self._test_sampler,batch_sampler=self._test_batch_sampler)\n```\n\nstart_predict()方法是算法在predict()方法开始时需要完成的操作。\n\n```python\ndef start_predict(self, *args, **kwargs):\n    self._network.eval()\n    if self.ema is not None:\n        self.ema.apply_shadow()\n    self.y_est = torch.Tensor().to(self.device)\n```\n\npredict_batch_loop()方法是通过循环对所有待预测数据进行预测的过程。其内部有start_predict_batch()、estimate()、end_predict_batch()三个方法。\n\n```python\ndef predict_batch_loop(self):\n    with torch.no_grad():\n        for idx,X,_ in self._estimate_dataloader:\n            self.start_predict_batch()\n            idx=to_device(idx,self.device)\n            X=X[0] if isinstance(X,(list,tuple)) else X\n            X=to_device(X,self.device)\n            _est=self.estimate(X=X,idx=idx)\n            _est = _est[0] if  isinstance(_est,(list,tuple)) else _est\n            self.y_est=torch.cat((self.y_est,_est),0)\n            self.end_predict_batch()\n```\n\nstart_predict_batch()方法是在每一批次数据预测开始前的操作。\nDeepModelMixin默认没有任何操作，可以根据算法需求进行添加。\n\n```python\ndef start_predict_batch(self, *args, **kwargs):\n    pass\n```\n\nestimate()方法是对于每一批次数据进行预测的过程。\n\n```python\n@torch.no_grad()\ndef estimate(self, X, idx=None, *args, **kwargs):\n    outputs = self._network(X)\n    return outputs\n```\n\nend_predict_batch()方法是在每一批次数据预测结束后的操作。\nDeepModelMixin默认没有任何操作，可以根据算法需求进行添加。\n\n```python\ndef end_predict_batch(self, *args, **kwargs):\n    pass\n```\n\nend_predict()方法是在predict()方法结束时需要进行的操作，包含get_predict_result()方法。\n\n```python\ndef end_predict(self, *args, **kwargs):\n    self.y_pred = self.get_predict_result(self.y_est)\n    if self.ema is not None:\n        self.ema.restore()\n    self._network.train()\n```\n\nget_predict_result()方法根据网络输出结果最终获得预测结果的过程。\n\n```python\n@torch.no_grad()\ndef get_predict_result(self, y_est, *args, **kwargs):\n    if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n        y_score = Softmax(dim=-1)(y_est)\n        max_probs, y_pred = torch.max(y_score, dim=-1)\n        y_pred = y_pred.cpu().detach().numpy()\n        self.y_score = y_score.cpu().detach().numpy()\n        return y_pred\n    else:\n        self.y_score = y_est.cpu().detach().numpy()\n        y_pred = self.y_score\n        return y_pred\n```\n\nevaluate()方法是模型的评估过程，参数‘valid’为True时用于模型训练过程中的验证，否则用于模型训练结束后的性能评估。\n\n```python\n@torch.no_grad()\ndef evaluate(self,X,y=None,valid=False):\n\n    if isinstance(X,Dataset) and y is None:\n        y=getattr(X,'y')\n\n    self.y_pred=self.predict(X,valid=valid)\n    self.y_score=self.y_score\n\n    if self.evaluation is None:\n        return None\n    elif isinstance(self.evaluation,(list,tuple)):\n        performance=[]\n        for eval in self.evaluation:\n            if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                score=eval.scoring(y,self.y_pred,self.y_score)\n            else:\n                score = eval.scoring(y,self.y_pred)\n            performance.append(score)\n            if self.verbose:\n                print(score, file=self.file)\n        self.performance = performance\n        return performance\n    elif isinstance(self.evaluation,dict):\n        performance={}\n        for key,val in self.evaluation.items():\n            if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n                performance[key]=val.scoring(y,self.y_pred,self.y_score)\n            else:\n                performance[key] = val.scoring(y, self.y_pred)\n            if self.verbose:\n                print(key,' ',performance[key],file=self.file)\n            self.performance = performance\n        return performance\n    else:\n        if self._estimator_type == 'classifier' or 'classifier' in self._estimator_type:\n            performance=self.evaluation.scoring(y,self.y_pred,self.y_score)\n        else:\n            performance = self.evaluation.scoring(y, self.y_pred)\n        if self.verbose:\n            print(performance, file=self.file)\n        self.performance=performance\n        return performance\n```\n\n以FixMatch算法为例，由于继承了DeepModelMixin中的大量模块，仅变动了init_transform()、train()和get_loss()三个方法即可完成对FixMatch算法的完整实现。可见在LAMDA-SSL的框架下进行深度半监督学习算法的自定义非常便捷。\n\n```python\nimport copy\nfrom LAMDA_SSL.Base.InductiveEstimator import InductiveEstimator\nfrom LAMDA_SSL.Base.DeepModelMixin import DeepModelMixin\nfrom sklearn.base import ClassifierMixin\nimport LAMDA_SSL.Config.FixMatch as config\nfrom LAMDA_SSL.Loss.Cross_Entropy import Cross_Entropy\nfrom LAMDA_SSL.Loss.Semi_Supervised_Loss import Semi_supervised_loss\nimport torch\n\n\nclass FixMatch(InductiveEstimator, DeepModelMixin, ClassifierMixin):\n    def __init__(self,\n                 threshold=config.threshold,\n                 lambda_u=config.lambda_u,\n                 T=config.T,\n                 mu=config.mu,\n                 weight_decay=config.weight_decay,\n                 ema_decay=config.ema_decay,\n                 epoch=config.epoch,\n                 num_it_epoch=config.num_it_epoch,\n                 num_it_total=config.num_it_total,\n                 eval_epoch=config.eval_epoch,\n                 eval_it=config.eval_it,\n                 optimizer=config.optimizer,\n                 scheduler=config.scheduler,\n                 device=config.device,\n                 train_dataset=config.train_dataset,\n                 labeled_dataset=config.labeled_dataset,\n                 unlabeled_dataset=config.unlabeled_dataset,\n                 valid_dataset=config.valid_dataset,\n                 test_dataset=config.test_dataset,\n                 train_dataloader=config.train_dataloader,\n                 valid_dataloader=config.valid_dataloader,\n                 test_dataloader=config.test_dataloader,\n                 augmentation=config.augmentation,\n                 network=config.network,\n                 train_sampler=config.train_sampler,\n                 train_batch_sampler=config.train_batch_sampler,\n                 valid_sampler=config.valid_sampler,\n                 valid_batch_sampler=config.valid_batch_sampler,\n                 test_sampler=config.test_sampler,\n                 test_batch_sampler=config.test_batch_sampler,\n                 labeled_dataloader=config.labeled_dataloader,\n                 unlabeled_dataloader=config.unlabeled_dataloader,\n                 labeled_sampler=config.labeled_sampler,\n                 unlabeled_sampler=config.unlabeled_sampler,\n                 labeled_batch_sampler=config.labeled_batch_sampler,\n                 unlabeled_batch_sampler=config.unlabeled_batch_sampler,\n                 parallel=config.parallel,\n                 evaluation=config.evaluation,\n                 file=config.file,\n                 verbose=config.verbose\n                 ):\n        DeepModelMixin.__init__(self, train_dataset=train_dataset,\n                                valid_dataset=valid_dataset,\n                                labeled_dataset=labeled_dataset,\n                                unlabeled_dataset=unlabeled_dataset,\n                                test_dataset=test_dataset,\n                                train_dataloader=train_dataloader,\n                                valid_dataloader=valid_dataloader,\n                                test_dataloader=test_dataloader,\n                                augmentation=augmentation,\n                                network=network,\n                                train_sampler=train_sampler,\n                                train_batch_sampler=train_batch_sampler,\n                                valid_sampler=valid_sampler,\n                                valid_batch_sampler=valid_batch_sampler,\n                                test_sampler=test_sampler,\n                                test_batch_sampler=test_batch_sampler,\n                                labeled_dataloader=labeled_dataloader,\n                                unlabeled_dataloader=unlabeled_dataloader,\n                                labeled_sampler=labeled_sampler,\n                                unlabeled_sampler=unlabeled_sampler,\n                                labeled_batch_sampler=labeled_batch_sampler,\n                                unlabeled_batch_sampler=unlabeled_batch_sampler,\n                                epoch=epoch,\n                                num_it_epoch=num_it_epoch,\n                                num_it_total=num_it_total,\n                                eval_epoch=eval_epoch,\n                                eval_it=eval_it,\n                                mu=mu,\n                                weight_decay=weight_decay,\n                                ema_decay=ema_decay,\n                                optimizer=optimizer,\n                                scheduler=scheduler,\n                                device=device,\n                                evaluation=evaluation,\n                                parallel=parallel,\n                                file=file,\n                                verbose=verbose\n                                )\n        self.lambda_u = lambda_u\n        self.threshold = threshold\n        self.T = T\n        self.weight_decay = weight_decay\n        self._estimator_type = ClassifierMixin._estimator_type\n\n    def init_transform(self):\n        self._train_dataset.add_unlabeled_transform(copy.deepcopy(self.train_dataset.unlabeled_transform), dim=0, x=1)\n        self._train_dataset.add_transform(self.weak_augmentation, dim=1, x=0, y=0)\n        self._train_dataset.add_unlabeled_transform(self.weak_augmentation, dim=1, x=0, y=0)\n        self._train_dataset.add_unlabeled_transform(self.strong_augmentation, dim=1, x=1, y=0)\n\n    def train(self, lb_X, lb_y, ulb_X, lb_idx=None, ulb_idx=None, *args, **kwargs):\n        w_lb_X = lb_X[0] if isinstance(lb_X, (tuple, list)) else lb_X\n        lb_y = lb_y[0] if isinstance(lb_y, (tuple, list)) else lb_y\n        w_ulb_X, s_ulb_X = ulb_X[0], ulb_X[1]\n        batch_size = w_lb_X.shape[0]\n        inputs = torch.cat((w_lb_X, w_ulb_X, s_ulb_X))\n        logits = self._network(inputs)\n        lb_logits = logits[:batch_size]\n        w_ulb_logits, s_ulb_logits = logits[batch_size:].chunk(2)\n        train_result = (lb_logits, lb_y, w_ulb_logits, s_ulb_logits)\n        return train_result\n\n    def get_loss(self, train_result, *args, **kwargs):\n        lb_logits, lb_y, w_ulb_logits, s_ulb_logits = train_result\n        sup_loss = Cross_Entropy(reduction='mean')(logits=lb_logits, targets=lb_y)\n        pseudo_label = torch.softmax(w_ulb_logits.detach() / self.T, dim=-1)\n        max_probs, targets_u = torch.max(pseudo_label, dim=-1)\n        mask = max_probs.ge(self.threshold).float()\n        unsup_loss = (Cross_Entropy(reduction='none')(s_ulb_logits, targets_u) * mask).mean()\n        loss = Semi_supervised_loss(lambda_u=self.lambda_u)(sup_loss, unsup_loss)\n        return loss\n```\n\n# 用户指南\n\nLAMDA-SSL实现了30种半监督学习算法，其中包含12种基于经典机器学习的算法和18种基于深度学习的算法，为用户提供了更多的选择空间。\n\n## 基于经典机器学习的半监督学习算法\n\nLAMDA-SSL包含12种基于统计机器学习模型的半监督学习算法，其中用于分类任务的算法包括生成式方法SSGMM，半监督支持向量机类方法TSVM、LapSVM，基于图的方法Label Propagation、Label Spreading，基于分歧的方法Co-Training、Tri-Training，集成方法SemiBoost、Assemble；用于回归任务的算法包括CoReg；用于聚类任务的算法包括Constrained K Means、Constrained Seed K Means。\n\n### 生成式方法\n\n生成式半监督学习方法基于生成式模型，其假设数据由一潜在的分布生成而来，生成式方法建立了样本与生成式模型参数之间的关系，而半监督生成式方法将无标注数据的标注视为模型的隐变量数据，可以采用期望-最大化（EM）算法进行极大似然估计求解。\n\n#### SSGMM\n\nShahshahani等提出了SSGMM模型。SSGMM即半监督高斯混合模型，假设数据由一个高斯混合模型生成，即样本的边缘分布可以表示为若干个高斯分布混合在一起的结果，且通过混合参数为每个高斯分布赋予一个权重。SSGMM将每一个类别的样本分布对应一个高斯混合成分。对于有标注数据，其类别对应的的高斯混合成分已知，对于无标注数据，其对应的高斯混合成分用一个概率分布表示，并可以将其分类为概率最高的高斯混合成分对应的类别。SSGMM假设样本服从独立同分布，其似然函数为所有有标注数据的样本与标注联合分布与所有无标注数据样本的边缘概率分布的乘积，通过最大似然估计使似然函数最大化，得到使当前有标注数据与无标注数据共同出现概率最大的生成式模型参数，包括高斯混合模型各部分的方差、均值以及权重。由于该方法存在无标注数据的标注这一无法观测的隐变量，因此无法直接求解最大似然参数，因此SSGMM采用了EM算法解决该问题。EM算法分为两步，其中E步根据当前参数与可观测数据得到未观测数据的条件分布或期望，在SSGMM模型中，这一步利用贝叶斯公式跟据已观测样本和当前模型的参数求解了无标注数据属于每一混合成分的概率，即无标注数据类别的条件分布；M步根据当前已观测变量的值与隐变量的期望或概率分布对模型参数进行最大似然估计，即原先由于隐变量未知无法进行最大似然估计，E步之后得到了隐变量的期望或条件概率分布，最大似然估计就变得可行了，在SSGMM模型中，这一步利用已观测到的有标注样本与标注、无标注样本与E步得到的类别条件分布更新了高斯混合模型的参数。E步与M步以一种迭代的形式交替进行，直至收敛，即可实现同时利用有标注数据与无标注数据训练一个高斯混合模型，并通过贝叶斯公式即可得到基于此高斯混合模型的分类器。\n\n<!-- #### <font color=purple size=32>Semi-supervised Support Vactor Machine</font> -->\n### 半监督支持向量机方法\n\n支持向量机是机器学习领域最具代表性的算法之一。该类算法将二分类问题视为在样本空间中寻找合适的划分超平面。在线性可分的情况下，在所有能够完成正确分类的超平面中，最优的划分超平面应尽量位于不同类样本间的中间位置，可以提高模型对于未知样本进行预测的稳健性，即将各类样本中距离超平面最近的样本称为支持向量，不同类的支持向量距离超平面的距离相等，支持向量机算法的目的在于寻找距离其对应的支持向量最近的超平面。然而，在现实任务中，往往不存在一个可以将所有训练样本正确划分的超平面，即使存在，也难免会存在过拟合现象，因此一类支持向量机方法引入了软间隔（Soft Margin）机制，即允许超平面不必将所有样本正确分类，而是在优化目标中增加了对分类错误样本的惩罚。\n\n半监督支持向量机是支持向量机算法在半监督学习理论的推广。半监督支持向量机引入了低密度假设，即学习得到的超平面除了需要基于有标注样本使分类尽可能分开，也要尽可能穿过所有样本分布的低密度区域，从而合理利用无标注样本。LAMDA-SSL包含了两个半监督支持向量机方法：TSVM和LapSVM。\n\n<!-- ##### <font color=blue size=16>TSVM</font> -->\n### TSVM\n\nJoachims等[5]提出的TSVM是最基础的半监督支持向量机方法（如图9所示），是一种直推式方法。TSVM需要为每个无标注样本确定其标注，并寻找一个在有标注样本和无标注样本上间隔最大化的划分超平面。由于为无标注样本分配的标注并不一定是其真实有标注，在训练的初始阶段不能将无标注样本与有标注样本一视同仁，TSVM利用参数C_l和C_u分别代表对于有标注样本和无标注样本的惩罚量级，反应了对有标注样本和无标注样本重视程度。由于所有无标注样本的标注可能情况数量随无标注样本数量的增加呈指数级别上升，无法通过穷举的方式确定无标注样本的标注寻找全局最优解，TSVM使用了一种迭代的搜索方法为优化目标寻找近似解：首先基于有标注样本训练一个SVM，并用这个SVM对无标注样本进行预测；之后初始化C_l\\llC_u，并开始迭代，在迭代过程中利用所有样本求解新的超平面，并不断寻找一对可能都发生错误预测的无标注异类样本交换标注并重新训练，直到不再能找到符合条件的异类样本，通过加倍C_u的值增加对无标注样本的重视程度，开始新一轮的迭代，直到C_u与C_l相等；最后将得到的模型对无标注样本的预测结果作为无标注样本的标注，完成直推过程。\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/TSVM.png\" >\n<br>\n图9[5]： TSVM算法\n</div>\n\n<!-- ##### <font color=blue size=56>LapSVM</font> -->\n### LapSVM\nBelkin等[5]基于流形假设提出了LapSVM。经典的SVM算法追求使支持向量间隔最大化，这只考虑了样本在特征空间的分布情况，然而在实际应用中，高维空间中的样本往往都分布在低维的黎曼流形上，仅依赖于样本在特征空间的间隔进行划分的支持向量机容易忽视样本分布的本质特征。LapSVM在SVM的优化目标的基础上增加了一项流形正则化项，对样本的本质分布进行了引导。LapSVM在所有样本的基础上构建了图模型，通过样本的特征间的相似性得到图模型的权重矩阵，并计算其Laplace矩阵，通过Laplace正则项引导模型对于图中临近样本的预测结果尽可能一致。不同于TSVM，LapSVM仅对有标注样本的错误分类进行惩罚，但是在构建图模型时同时使用了所有样本，从而利用样本在流形上的分布使无标注样本参与了学习的过程。\n\n### 基于图的方法\n\n基于图的半监督学习方法将数据集表示为一个图结构模型，以样本为节点，以样本间的关系为边，在半监督学习中，存在有标注数据与无标注数据，因此图中的结点有一部分存在标注，而另一部分没有标注，因此基于图的直推式半监督学习可以被视为标注在图中传播的过程。\n\n#### Label Propagation\n\nZhu等[7]提出了Label Propagation算法。该算法以数据集中的样本为结点，样本间的关系为边进行全连接或k近邻构图，边权往往采用样本在原始数据空间或核空间（其中高斯核最为常用）的相似度进行表示。Label Propagation算法的目的在于将有标注数据的标注通过图结构向无标注数据传播，完成对无标注数据的预测，实现直推式半监督学习。Label Propagation的优化目标为模型预测结果在图结构中的Laplacian一致性正则项，即以边权为权重，将相邻节点间模型预测结果差异的加权均方误差作为优化目标。由于有标注数据的标注是固定的，因此Label Propogation仅需将Laplacian一致性正则项作为优化目标，求解无标注数据的标注使优化目标取最小值，即模型对于图上临近点的预测应该尽可能一致，使优化目标对无标注数据的标注求偏导数，使其偏导数为0，就可以得到其最优解，经证明这个通过直接计算得到的闭式最优解与不断迭代进行无限次标注传播最终收敛到的结果是一致的。通过直接的推导即可求得精确解，不需要模拟标注传递的过程，不需要为了收敛进行多次迭代，这也是Label Propagation对于其他图半监督学习方法的优势所在。\n\n#### Label Spreading\n\nZhou等[8]提出了Label Spreading算法。不同于Label Propagation算法在传播过程中固定了有标注数据的标注，使其在整个传播过程中都保持不变，这保护了真实有标注数据对模型的影响，但是对于存在数据噪声的情况，Label Prapogation会存在一定的局限性，且Label Propagation算法中标注全部指向无标注数据，这可能会堵塞一些需要通过有标注数据结点进行传播的路径，使信息在图中的传播收到了一定的限制。而Label Spreading算法使标注可以在对所有临近结点进行广播，对于传播后结果与真实标注不符的有标注数据，Label Spreading会对其进行惩罚，而不是完全禁止。Label Spreading的优化目标有两项，第一项与Label Propagation的优化目标相同，但不存在模型对有标注数据预测结果必须等于其真实标注这一限制，第二项为对有标注数据预测损失的惩罚，需要设置一个惩罚参数作为其权重。由于优化目标不同，Label Propagation存在闭式解，而Label Spreading则需要通过迭代的方式求解，需要设置一个迭代折中参数，即每轮迭代都需要将本轮迭代得到的传播结果与样本的初始标注利用折中参数进行权衡作为当前预测结果。\n\n### 基于分歧的方法\n\n基于分歧的半监督学习方法需要生成具有显著分歧、性能尚可的多个学习器，利用学习器之间的分歧对无标注数据加以利用，这类方法较少受到模型假设、损失函数非凸性和数据规模问题的影响，学习方法简单有效、理论基础相对坚实、适用范围较为广泛。\n\n\n#### Co-Training\n\nBlum等[9]提出了Co-Training（如图10所示）。Co-Training即协同训练方法，用两个基学习器互相协同，辅助彼此的训练，即对于在一个学习器上自信度比较高的无标注样本，Co-Training会将该样本与其伪标注传递给另一个学习器，通过这种交互的形式，一个学习器上学到的知识被传递到了另一个学习器上。由于两个基学习器存在差异，其差异性决定了它们对于相同样本的学习难度会不同，Co-Training有效地利用了这种不同，使单独地学习器不仅可以使用其本身自信的伪标注，还可以使用另一个学习器自信的伪标注，加大了对无标注数据的利用程度，最后将两个学习器进行集成作为最终的预测结果。为了使两个基学习器有一定的差异，Co-Training采用了多视图假设，即基于相同数据的不同样本特征集合训练的模型应该对相同样本有相同的预测结果。Co-Training将样本的特征划分为两个集合，作为对样本从两个不同视图的观测，初始状态两个学习器的训练数据仅为不同视图下的有标注数据，在迭代过程中，在一个学习器上伪标注自信度高的无标注样本及其伪标注会被同时加入两个学习器的训练数据集，用于下一轮的训练，迭代持续至两个学习器的预测均不再发生变化为止。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/Co-Training.png\" >\n<br>\n图10[3]：Co-Training算法\n</div>\n\n#### Tri-Training\n\nZhou等[10]提出了Tri-Training方法。由于Co-Training等多学习器协同训练的方法必须要求基学习器之间需要存在差异，如数据视图不同或模型不同。但在实际应用中，可能只有单一视图的数据，且人为对原始数据进行特征切割会一定程度上损失特征间关系的相关信息，且对于划分方式需要一定的专家知识，错误划分可能会导致严重的性能下降；而采用不同类型的模型进行协同训练又需要设置多个监督学习器，考虑到封装方法较其他半监督学习方法的优势在于可以直接将监督学习算法扩展到半监督学习任务，因此实际应用中使用封装方法的场景往往只有一个监督学习算法，设计额外的监督学习算法一定程度上损失了封装方法的便捷性。Tri-Training方法从数据采样角度解决了这一问题，仅使用一个监督学习算法，对数据进行多次有放回随机采样（Boostrap Sample），生成多个不同的训练数据集，从而达到用同一算法学习得到多个不同模型的目的。不同于其他封装方法采用模型对无标注样本的自信度作为是否将无标注数据纳入训练数据集的依据，但是有些情况下模型会出现对错误分类过度自信的情况，导致伪标注与真实标注间可能存在较大的偏差，Tri-Training使用三个基学习器协同训练，在一个基学习器的训练过程中，对于无标注样本可以用另外两个基学习器判断是否应该将其纳入训练数据，如果在一轮迭代中，两个学习器的共同预测错误率较低且对于该无标注样本拥有相同的预测结果，那么这一无标注数据及其伪标注更可能会对当前训练的基学习器产生积极影响，使用两个模型的预测一致性判断是否使用无标注样本的方法相较仅使用一个模型的自信度的方法更加具备稳健性。另外不同于其他封装方法被选中的无标注数据会已知存在于训练数据中，这可能会导致被错误预测的无标注样本会对学习器造成持续性影响，永远无法被纠正，在Tri-Training算法中每一轮迭代采用的无标注数据集及其伪标注都会被重新选择。Tri-Training拥有扎实的理论基础，并基于理论基础在每轮迭代中对无标注数据的利用增加了限制条件，这些限制条件主要针对一个基学习器每一轮迭代训练中另外两个学习器的共同预测错误率和无标注数据的使用数量：当另外两个基学习器的共同预测错误率较高时，即使它们的预测结果具有一致性，都应该放弃在训练过程中使用无标注数据；当满足一致性的样本数量过多时，也应避免过度使用无标注数据，而是根据理论结果得到该轮迭代中使用无标注数据的数量上界，如果超出上界则应该通过采样进行缩减。对无标注数据使用的严格约束极大程度上增加了半监督模型的安全性，可以有效缓解因错误引入无标注数据导致模型性能下降的问题。\n\n### 集成方法\n\n在机器学习领域，使用单个学习器容易因欠拟合或过拟合造成模型偏差或方差过高，使模型泛化能力不足，集成学习将多个弱学习器结合起来，既提高了模型对假设空间的表示能力，又减弱了因单一学习器的错误造成的影响，提高了模型的可靠性。在半监督学习领域，由于无标注数据的加入，使用单一学习器为无标注数据设置伪标注这一做法使单一学习器的不稳定性进一步加剧，对有效的集成学习方法有更强的依赖。\n\n#### Assemble\n\nBennett等[11]提出了Assemble方法。Assemble即自适应监督集成，是基于自适应提升（AdaBoost）方法在半监督学习领域的扩展。提升（Boosting）方法是集成学习中的一类重要方法，这类方法通过当前集成学习器的预测效果对数据集进行采样，采样过程会更加重视目前集成学习器预测效果不佳的样本，用采样后的数据训练新一轮的学习器，这一策略使模型在每一轮新的弱学习器学习过程中可以更多关注目前集成学习器学习效果较差的样本，不断提高模型的泛化能力和稳健性。AdaBoost是Boosting类方法中最具代表性的方法，该方法根据模型预测结果与样本自身标注的差异自适应地调整样本权重，并根据样本权重对数据集进行采样用于学习下一轮迭代弱学习器的学习，并根据每一轮弱学习器的准确率确定其权重，加入到集成学习器中，其中准确率更高的弱学习器拥有更高的集成权重。ASSEMBLE通过对无标注数据添加伪标注的方法将AdaBoost方法在半监督学习领域进行了推广，初始阶段无标注样本的伪标注为与其最接近的有标注样本的标注，且无标注数据与有标注数据拥有不同的权重，在迭代过程中，每一轮无标注数据的伪标注被更新为该轮集成学习器的预测结果，随着迭代的进行，集成学习器效果越来越好，伪标注也越来越准确，进一步推动着新一轮弱学习器对集成学习器产生更有益的影响。\n\n#### SemiBoost\n\nMallapragada等[12]提出了SemiBoost方法（如图11所示）。不同于Assemble方法仅将模型的预测结果与真实标注或伪标注之间的差异性作为对样本采样的依据，没有考虑样本之间的关系，SemiBoost基于图半监督学习方法，指出在采样时应该将样本间的相似度也纳入考量，应该对样本间相似度较高但目前集成学习器的预测结果不一致性较大的样本设置更大的权重，SemiBoost使集成学习器在不断迭代过程中，不仅提高了模型的泛化能力，还提高了模型对于相似样本预测的一致性，使模型更加稳健，这一过程中无标注样本发挥了更大的作用。SemiBooost每一轮迭代中对于新的弱学习器进行学习，其优化目标由两项组成，第一项以有标注样本集与无标注样本集间的相似度作为权重，惩罚了无标注数据的伪标注和与其相近的有标注数据的真实标注之间的差异性，这接近于标注传播的效果，使得模型可以根据图结构通过样本相似性和有标注数据的真实标注得到无标注数据的伪标注，使伪标注更大程度上接近真实标注；第二项以无标注样本集内部的相似度作为权重，对相似度较高的样本之间预测差异较大的无标注样本赋予更高的权重，缓解了噪声对模型的影响。\n\n<div align=center>\n<img width=\"700px\"  src=\"./Imgs/SemiBoost.png\" >\n<br>\n图11[12]：SemiBoost算法\n</div>\n\n### 半监督回归方法\n\n目前大多数半监督学习算法都是针对分类任务而设计的，且不能自然地扩展到回归任务，仅有少部分工作针对半监督学习回归任务，这很大程度上是因为回归任务相较分类任务更难提出合理的假设，研究半监督回归相较半监督分类有着更多的困难。目前这一领域还有待更多的研究成果，半监督回归任务在现实场景中依然具备较大的需求和应用价值。\n\n#### CoReg\n\nZhou等[13]提出了CoReg方法。CoReg将Co-Training算法引入了回归任务，在原本用于分类的封装类算法中，往往假设模型越自信的样本越会对之后的训练产生积极影响，因此将模型预测结果中类别概率的最大值作为模型对该样本的自信度，根据学习器对无标注数据预测的自信度选择一部分无标注样本及其伪标注加入到训练数据中参与之后迭代的训练，但是在回归任务中难以评估模型对无标注样本的自信度，因此难以选择无标注样本加入训练过程，这也是这一类方法难以应用于回归任务的一个重要原因。CoReg解决了这一问题，从而将Co-Training算法应用在了回归任务中。CoReg使用k近邻（kNN）模型作为基学习器，对于两个基学习器，为了保持它们之间存在差异性，分别使用了不同的阶数计算闵可夫斯基（Minkowsky）距离作为k近邻模型中样本间的距离。为了度量模型对样本的自信度，对于每一无标注样本，模型先预测其实值伪标注，将其与所有参与训练的样本结合起来重新训练一个学习器，并用均方误差损失评估该样本对它的k个近邻结点产生的影响，如果这些k近邻结点的均方误差降低，说明加入该无标注样本更可能对之后的训练产生更积极的影响，因此CoReg将加入一个无标注样本前后均方误差的差异作为自信度的评估标准，每一轮迭代将一个学习器上自信度最高的无标注样本及其实值伪标注加入到另一个学习器的训练数据中，从而完成了Co-Training的训练过程。\n\n### 半监督聚类方法\n\n不同于半监督分类和半监督回归任务，用无标注数据辅助监督学习的过程，半监督聚类任务在原本无监督聚类的基础上引入了监督信息以辅助无监督学习的过程，其中监督信息不一定是有标注数据，也可能是其他与真实标注有关的知识，由于监督信息的不同也产生了不同多种半监督聚类方法。\n\n#### Constrained k-means\n\nWagstaff等[14]提出了Constrained k-means算法。该算法在k-means聚类算法的基础上引入了称为必连（Must Link）和勿连（Connot Link）的约束作为监督信息，其中必连约束限制了一些样本必须属于同一聚类簇，而勿连约束限制了一些样本必须属于不同的聚类簇，且必连约束与勿连约束存在传递机制，如A与B必连且B与C必连则A与C必连，A与B勿连且B与C必连则A与C勿连。k-means算法将样本归属于簇中心与样本最近的簇，与之相似的是Constrained k-means算法也会优先考虑簇中心与样本最近的簇，但与之不同的是Constrained k-means算法会在将一样本归为一个簇时，会首先判断该样本与簇内样本间是否违反必连和勿连约束，如果违反，Constrained k-means会重新考虑下一个符合条件的簇，如果所有簇都不能满足约束，则会发出聚类失败的警告，需要随机选择不同的聚类中心重新初始化。\n\n#### Constrained Seed k-means\n\nBasu等[15]提出了Constrained Seed k-means算法。该算法不同于Constrained k-means将必连和勿连约束作为监督信息，而是直接采用了有标注数据作为监督信息。由于有了部分有标注数据，可以通过直接在有标注数据集上计算类别均值的方式计算聚类中心，这有效缓解了聚类算法中因初始聚类中心选择的随机性造成的聚类不稳定，且可以将有标注数据集上的类别数量作为聚类算法中的簇数k，不需要再人为选择k值，避免了聚类时不合理的簇数选择造成的聚类结果不理想。不同于k-means算法在迭代过程中对所有的样本根据其余目前所有簇中心的距离判断其应归属的簇，Constrained Seed k-means算法在迭代过程中仅对无标注数据所属的簇进行更新，对于有标注数据会根据其真实标注固定其所属的簇，不会因簇中心的变化而改变。使用有标注数据参于聚类过程时聚类器更加可靠，缓解了无监督聚类的盲目性，有效地减弱了聚类结果与样本真实标注间差距过大和由于随机性带来的不稳定现象。\n\n## 基于深度学习的半监督学习算法\n\nLAMDA-SSL包含18种基于深度模型的半监督学习算法：其中用于分类任务的算法包括一致性正则方法Ladder Network、Π Model、Temporal Ensembling、Mean Teacher、VAT、UDA，基于伪标注的方法Pseudo Label、S4L，混合方法ICT、MixMatch、ReMixMatch、FixMatch、FlexMatch，生成式方法ImprovedGAN、SSVAE，图神经网络方法SDNE、GCN、GAT；用于回归任务的算法包括一致性正则方法Π Model Reg、Mean Teacher Reg和混合方法ICT Reg。\n\n### 一致性正则方法\n\n深度学习方法通过设置损失函数，以梯度下降的优化方法引导模型训练的方向。一致性正则方法往往基于一致性假设，即假设对于样本增加一定程度的扰动，其预测结果应尽可能保持一致，从而在损失函数中引入了关于一致性的正则化项，使没有标注的样本也能参与到模型训练的过程中来，有助于提升模型对于噪声的稳健性。\n\n#### Ladder Network\n\nRasmus等[16]提出了LadderNetwork方法（如图12所示）。该方法采用了自编码器结构，其中编码器最后一层的输出为分类软标注，即编码器同时具有分类功能，并采用两种编码方式，第一种为不带噪的编码器结构，即经典的编码器结构，第二种为带噪的编码器结构，即在经典的编码器基础上每一层的输入都会加入一定的噪声。LadderNetwork方法首先对样本分别进行带噪编码与不带噪编码，得到每个层次的带噪编码表示和不带噪编码表示；之后用解码器对带噪编码结果进行解码，得到每个层次的带噪解码表示；最后用均方误差损失（MSE）计算每一层次（包括原始输入数据作为第零层）的不带噪编码表示与带噪解码表示的不一致性，并通过原先确定的权重对各层次的不一致性进行加权作为无监督损失函数，从而利用无标注数据提升模型预测的稳健性。LadderNetwork算法的一致性正则化将带噪编码表示作为桥梁，惩罚了不带噪编码表示与带噪解码表示间的不一致性，一方面可以得到一个自编码器，使模型编码器与解码器各层次的表示可以保持一致，解码器利用编码后的结果可以尽可能地还原编码器各层表示以及原始数据；另一方面也可以使模型在存在噪声的情况下，保证隐层表示与没有噪声时尽可能一致，可以对抗微小的扰动。\n\n<div align=center>\n<img width=\"300px\" height=\"300px\"  src=\"./Imgs/LadderNetwork.png\" >\n<br>\n图12[3]：LadderNetwork算法\n</div>\n\n#### UDA\n\nXie等[17]提出了UDA方法（如图13所示）。不同于LadderNetwork，UDA只对输入数据进行扰动，并不对隐层进行扰动，且UDA不一定采用高斯噪声进行扰动，而是可能可以采用多样的数据增广方式对数据进行增广。相比高斯噪声，UDA使用的数据增广，如图片旋转或文本替换等会对数据产生更大的影响，可以进一步提升模型的稳健性。UDA对无标注数据进行一次数据增广，之后比较增广前后的数据的预测结果，利用均方误差损失计算一致性正则项作为无监督损失，从而使无标注数据参与训练过程。\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/UDA.png\" >\n<br>\n图13[3]：UDA算法\n</div>\n\n#### Pi Model\n\nLaine等[18]提出了Pi Model方法（如图14所示）。不同于UDA将无标注数据进行一次增广后比较增广前后的数据的预测结果，计算一致性正则项，Pi Model分别对数据进行两次随机数据增广，并分别将两次增广的结果作为神经网络模型的输入进行预测，将预测结果的不一致性作为无监督损失，从而将无标注数据引入训练过程。由于增广过程的随机性，该方法两次增广会得到两项语义相似但特征可能略有不同的数据，通过一致性正则使模型对拥有一定界限的不同增广结果能产生相近的预测结果。\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/PiModel.png\" >\n<br>\n图14[3]：Π Model算法\n</div>\n\n#### Temporal Ensembling\n\nLaine等[18]还提出了Temporal Ensembling方法（如图15所示）。该方法对Pi Model进行了一些改进。在Pi Model中，对于每个无标注数据，Pi Model需要分别对其进行两次增广和两次伪标注预测以计算其结果的不一致性，这带来了较大的算力消耗。Temporal Ensembling方法将其中一次伪标注预测改为对历史伪标注的指数移动平滑（EMA），即对同一数据的历史预测结果进行加权平均从而将历史预测集成起来，其中每一轮的伪标注权重会随着后续轮次的增加以指数级别的速度衰减。这种集成方式在有效地保留了历史伪标注信息，通过计算当前伪标注与历史伪标注间的一致性作为得到函数，并在每一轮次结束时更新历史伪标注。EMA方法极大程度上保障了模型的稳健性，避免了模型过度受单轮预测的影响，也减慢了模型对历史信息的遗忘速度，且每一轮次中对于每个数据只需要进行一次增广和预测，历史信息仅需进行一次加权平均即可维护，相较Pi Model极大地减少了算力消耗。\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/TemporalEnsembling.png\" >\n<br>\n图15[3]：Temporal Ensembling算法\n</div>\n\n#### Mean Teacher\n\nTarvainen等[19]提出了Mean Teacher方法（如图16所示）。该方法借助了知识蒸馏的思想，即将教师模型的预测结果作为伪标注，用于训练学生模型，确保教师模型与学生模型预测结果的一致性，从而将知识由较为复杂的教师模型蒸馏到较为简单的学生模型。经典的知识蒸馏方法的目的在于模型的简化，即教师模型采用较为复杂的模型，学生模型采用较为简单的模型，而Mean Teacher的目的在于通过一致性使无标注数据参与学习过程并提升模型的稳健性，因此教师模型并非是复杂模型，而是在学生模型的基础上对参数进行指数移动平滑，这相对于经典的知识蒸馏方法减少了计算开销。Temporal Ensembling方法对每一轮次的预测结果进行指数移动平滑的计算，但是只有在每一轮次结束时才会对整体的历史信息进行更新，对于大型的数据集，会导致历史信息不能及时对同一训练轮次（Epoch）后续批次（Batch）的数据产生影响，会导致对历史信息的利用不够及时的问题。不同于Temporal Ensembling，Mean Teacher改为对模型参数采用指数平滑计算，在每一批次训练结束后都会及时更新模型参数的历史信息，有效地解决了历史信息更新与利用不及时的问题，这使得Mean Teacher方法更加灵活，通用性更强。\n<div align=center>\n<img width=\"300px\" height=\"300px\" src=\"./Imgs/MeanTeacher.png\" >\n<br>\n图16[3]：Mean Teacher算法\n</div>\n\n#### VAT\n\nMiyato等[20]提出了VAT（如图17所示）。不同于对数据增加随机噪声的方法，VAT的思想在于对数据增加对抗噪声，使模型在数据受一定限制条件下噪声影响时的最坏表现可以更好，这对应了博弈问题中的零和博弈问题和优化问题中的最小最大化问题。对于经典的监督对抗算法，通常将真实标注与模型预测结果之间的交叉熵损失作为对抗优化的目标，首先通过内层优化得到对于当前模型和数据使损失最大的噪声，之后通过外层优化得到在对数据施加噪声的情况下的模型参数，内外优化交替进行，使模型在应对数据噪声时可以在最坏情况下表现得不会太差。其中，外层优化为对模型参数得优化，往往通过梯度下降来进行，而内部优化是针对数据噪声的优化，该优化不存在闭式解，且因针对不同数据应采用不同的对抗噪声，不适宜用梯度优化，需要对最优噪声进行近似，在经典的监督对抗算法中常采用线性近似，即先对无噪声数据进行预测并计算损失函数的值，进行梯度回传，得到对于无噪声数据的梯度，并将归一化后的梯度与噪声上界的乘积最为对抗噪声。\n不同于经典的监督对抗算法，VAT需要解决半监督场景存在无标注数据的问题，即无法通过监督计算损失后回传梯度计算对抗噪声，为了解决这一问题，VAT算法采用了一致性策略，即将监督损失改为一致性损失，将利用真实标注计算损失改为利用模型分别对无噪声数据和噪声数据进行预测得到噪声伪标注与无噪声伪标注，计算二者间的一致性作为无监督损失。在VAT算法中，不同于监督的对抗算法，对于无标注数据内层优化无法采用线性近似，这是因为在监督的对抗算法的内层优化中，首先需要计算真实标注与模型对不加噪数据预测结果间的分类损失，而VAT用伪标注代替了真实标注，导致对于不加噪数据回传的梯度始终为0，无法得到梯度方向从而无法得到对抗噪声，因此VAT采用了二阶泰勒近似代替了线性近似，将计算对抗噪声的问题转化为了计算损失函数对于噪声的海森矩阵的主特征向量的问题。由于对于d维数据噪声，计算其海森（Hessian）矩阵的特征向量需要O\\left(d^3\\right)的时间复杂度，为了解决计算复杂度过高的问题，VAT采用了幂迭代（Power Iteration）方法求解近似的矩阵特征向量，即先对近似特征向量进行随机采样，并不断用矩阵与当前近似特征向量相乘得到新的近似特征向量，不断进行该过程即可在较低时间消耗的情况下得到较好的近似结果，为了进一步避免对海森矩阵的直接计算，VAT采用了有限差分（Finite Difference）方法近似求解矩阵与近似特征向量的乘积。相较其他基于一致性正则的方法，VAT方法采用对抗噪声比采用随机噪声可以进一步提升模型的稳健性，避免了随机性对实验结果的过度干扰，基于对抗的方法更加可靠地保证了模型在最坏情况下的表现，具有更好的理论基础，且VAT在计算对抗噪声时通过近似方法避免了过度的额外计算开销，并解决了监督对抗算法无法直接应用于无标注数据的困境。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/VAT.png\" >\n<br>\n图17[3]：VAT算法\n</div>\n\n### 伪标注方法\n\n基于伪标注的方法通过为无标注数据赋以伪标注从而使无标注数据对学习过程产生影响。且由于模型对于不同样本的自信度不同，基于伪标注的方法通常取自信度较高的样本与其伪标注参与训练过程。\n\n#### Pseudo Label\n\nLee等[21]提出了Pseudo Label方法（如图18所示）。该方法为最基础的伪标注方法，其损失函数包括两项，分别是监督损失和无监督损失，两部分都是交叉熵损失函数。其中对于无标注数据，Pseudo Label方法对神经网络输出结果进行softmax运算，得到样本属于各类别的自信度，Pseudo Label取自信度最高的类别作为样本的伪标注，用伪标注计算交叉熵损失。另外，在每一轮次中，并不是所有无标注样本都会参与训练过程，Pseudo Label设置了一个阈值，只有当本轮无标注样本的伪标注自信度大于所设阈值时，才会参加训练过程。Pseudo Label还设置了超参数用于控制监督损失与无监督损失的比重，并采用了预热（warmup）机制，刚开始训练时，无监督损失比重较低，随着训练的进行，无监督损失的比重越来越大。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/PseudoLabel.png\" >\n<br>\n图18[3]：Pseudo Label算法\n</div>\n\n#### S4L\n\nBeyer等[22]提出了S4L方法（如图19所示）。这一方法采用了自监督技术，其基本思想在于：无标注数据无法直接参与分类器的训练，但是可以利用自监督对表示层产生影响，使模型可以学到更好的隐层表示，从而有助于分类器的训练。该方法主要用于图像数据，随机取0^\\circle、90○、180○、270○之一作为度数对图像进行旋转操作，将角度作为伪标注，旋转后的图像与角度即可形成数据对，可以训练一个对角度进行分类的神经网络模型，虽然神经网络最后的分类层与目标任务不同，但其学到的隐层表示有助于对真实任务的学习。对于有标注数据，S4L也会进行同样的处理，使其拥有两个标注，代表旋转度数的伪标注和用于目标任务的真实标注，S4L对有标注数据用了两个分类层，其中之一是与无标注数据共享的度数分类器，另一个是用于目标任务的真实类别分类器，两个分类层共用相同的隐层。通过上述方式，S4L在训练自监督分类器的同时，使模型可以学习到更好的表示，从而提升了模型对目标任务的分类效果。与预训练与微调范式不同，S4L不用提前训练模型，而是可以同时处理有标注数据和无标注数据，并且相互促进，且有标注数据也参与了自监督学习过程，对数据进行了更大程度的利用。S4L也可以推广到其他类型的数据，需要采用与之对应的自监督训练方法。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/S4L.png\" >\n<br>\n图19[3]：S4L算法\n</div>\n\n### 混合方法\n\n不同的半监督学习技术之间往往不会冲突，很多常用的半监督学习算法不局限于仅使用一类技术，而是将一致性、伪标注等技术进行结合，各取所长，产生新的混合方法。混合方法可以同时利用不同技术的优势，从而达到更好的训练效果。由于同时使用了多种技术，混合方法往往更加具备通用性。\n\n#### ICT\n\nVerma等[23]提出了ICT方法（如图20所示）。ICT即插值一致性训练，通过Mixup[34]数据增广方法对数据与预测结果进行线性插值，通过比较模型对插值后样本的预测结果与模型对原始数据的预测结果的插值之间的一致性将无标注数据引入训练过程。Mixup由Beta分布生成一个混合参数，对两项数据按这一混合参数得到线性插值，得到两项数据的混合数据，以此实现数据增广。ICT方法的损失函数分为监督损失与无监督损失两部分，其中监督损失通过交叉熵函数计算，无监督损失则要通过插值一致性计算。对于每一批次的数据，ICT首先根据Beta分布采样一个混合参数，然后将该批次样本随机打乱，将打乱的批数据与未打乱的批数据以混合参数为比例进行Mixup混合，得到混合批数据，模型对未打乱批数据和混合批数据进行预测，得到未打乱预测结果与混合预测结果，并将未打乱预测结果按样本打乱顺序重新排列得到打乱预测结果，ICT将未打乱预测结果与打乱预测结果以和样本相同的混合参数进行线性插值，并将插值结果与混合预测结果间的不一致性作为无监督损失。对于混合后的无标注数据，ICT使模型输出的软标注接近于伪标注的混合，将一致性技术与伪标注技术结合起来，使模型更加稳健。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/ICT.png\" >\n<br>\n图20[3]：ICT算法\n</div>\n\n#### MixMatch\n\nBerthelot等[24]提出了MixMatch方法（如图21所示）。该方法也用了Mixup方法，但不同于ICT仅对无标注数据的样本与伪标注进行Mixup，MixMatch对有标注数据与无标注数据进行了混合，并对混合后的数据样本及其标注与伪标注进行了Mixup。MixMatch首先对无标注数据多次增广并进行多次预测，通过对多次预测结果求均值并进行锐化得到无标注数据的伪标注，对数据进行多次不同增广使模型的伪标注更加具备可靠性，对伪标注进行锐化降低了标注分布的熵，使分类界限尽可能穿过样本的低密度区域；之后MixMatch对有标注数据与无标注数据进行了结合与打乱，使无标注数据集与有标注数据集形成了一个新的混合数据集，从混合数据集中取出与原有标注数据集相同数量的数据进行Mixup作为新的有标注数据集，将混合数据中剩余数据与无标注数据集进行Mixup得到新的无标注数据集；最后MixMatch分别对新有标注数据集和新无标注数据集进行预测，用新有标注数据集的预测结果计算交叉熵作为监督损失，用新无标注数据的预测结果计算均方误差作为无监督损失，通过权重参数将二者结合起来作为模型的损失函数。不同于其他方法将有标注数据与无标注数据分别计算损失，MixMatch将有标注数据与无标注进行了结合、打乱、重新划分，这降低了因错误的伪标注导致模型性能下降的风险。在原本仅使用伪标注训练的过程中加入真实标注，有助于利用真实标注辅助无标注数据的训练，引导无标注一致性的正确训练方向，既保障了一致性正则原有的稳健性，还能使模型不会因伪标注与真实标注不符过度偏离目标。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/MixMatch.png\" >\n<br>\n图21[3]：MixMatch算法\n</div>\n\n#### ReMixMatch\n\nBerthelot等[25]还提出了ReMixMatch方法（如图22所示）。ReMixMatch是MixMatch的改进版本，其引入了两种技术：分布对齐和增广锚定。分布对齐目的在于使模型对于无标注数据预测得到的伪标注应与有标注数据的标注有相同的边缘概率分布，在深度学习中，模型的预测经常偏向数量较多的类别，另外MixMatch对软标注使用了锐化操作减少了标注分布的熵以促使分类边界尽可能通过低密度区域，这都导致了有标注数据的标注分布与无标注数据的伪标注分布产生了差异，这反映了为无标注数据赋予伪标注存在类别间的不公平现象，分布对齐技术有效缓解了这样的问题。分布对齐技术计算有标注数据的真实标注分布，在每一批次的训练中，计算其输出的软标注分布，对于一个样本的软标注，使其与真实标注分布与当前批次软标注分布的比值相乘得到对齐后的软标注，将对齐后的软标注进行锐化得到样本的伪标注。增广锚定是为了使模型适应更强的数据增广，对于监督学习方法，在一定程度内，对数据施加更强的数据增广可以进一步提升模型的泛化能力，但这是以监督学习中无论对样本施加强增广还是弱增广，标注都不会发生变化为前提。在半监督学习中，往往由模型对无标注数据的预测结果得到伪标注，伪标注会随着数据增广的形式而变化，如果对样本施加较强的增广，容易使伪标注过度偏离真实标注，无法发挥监督学习中强数据增广的作用，这也导致了MixMatch方法不能与较强的数据增广方式相容，ReMixMatch通过引入增广锚定技术首先对无标注样本进行弱数据增广，将模型对其预测的结果作为伪标注，并将其作为“锚”固定下来，这使得后续无论对无标注数据进行何种数据增广，都不会使其伪标注发生变化。ReMixMatch方法对无标注数据进行了一次弱数据增广和多次强数据增广，并都以模型对弱增广数据的预测结果经对齐与锐化后作为伪标注，由弱增广和所有强增广后的数据集组成更大的无标注数据集。之后ReMixMatch采用与MixMatch相同的策略对有标注数据集和无标注数据集进行组合、打乱与重新划分。另外，ReMixMatch的损失函数与MixMatch由较大的不同，ReMixMatch的有监督损失与无监督损失均采用交叉熵进行计算，且不同于MixMatch的损失函数仅包含监督损失与无监督损失两项，ReMixMatch增加了两项损失，这是由于MixMatch仅对Mixup后的数据集进行损失计算，虽然Mixup使模型拥有了更好的泛化性能，但是仅使用Mixup后的数据可能会忽略Mixup前数据集的一些信息，因此ReMixMatch从多个Mixup前的强增广数据集中取出一个，用于计算Mixup前数据的无监督损失作为损失函数第三项；ReMixMatch还借鉴了S4L的自监督策略，对取出的Mixup前的强增广数据集进行随机旋转并对其旋转角度进行预测，自监督进一步促进了模型隐层的学习，将对旋转角度分类的交叉熵损失作为自监督损失，用作损失函数的第四项。ReMixMatch以一个更为复杂的框架将多种技术融为一体，不仅结合了各方法的优势，且因为其全面性而更加通用。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/ReMixMatch.png\" >\n<br>\n图22[3]：ReMixMatch算法\n</div>\n\n#### FixMatch\n\nSohn等[26]提出了FixMatch方法（如图23所示）。FixMatch同样使用了强数据增广与弱数据增广，不同于ReMixMatch通过增广锚定技术利用弱数据增广固定无标注数据的伪标注，FixMatch更加关注模型对弱增广数据与强增广数据预测结果的一致性。与ReMixMatch相同的是FixMatch同样根据模型对弱增广数据的预测结果得到伪标注，FixMatch的伪标注为硬标注。之后FixMatch对无标注数据进行强增广，得到预测结果，FixMatch仅用模型自信的无标注数据进行训练，即设置一个阈值参数，仅当自信度大于阈值参数时，该数据才会参与训练过程。FixMatch利用模型对弱增广样本得到的伪标注和模型对强增广样本得到的预测结果计算交叉熵作为无监督损失，通过权重参数将无监督损失与监督损失结合起来作为FixMatch的损失函数。\n\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/FixMatch.png\" >\n<br>\n图23[3]：FixMatch算法\n</div>\n\n#### FlexMatch\n\nZhang等[27]提出了FlexMatch方法（如图24所示）。FlexMatch是对于FixMatch的改进，且注重于解决半监督学习中各类别间的不公平现象，FixMatch根据固定的阈值参数筛选自信度高的无标注样本及其伪标注参与模型训练过程，但有时虽然原始数据集是类别平衡的，但由于各类别学习难度不同，采用固定阈值进行筛选会导致一些难学习的类别相较易学习的类别更少参与训练过程，这样模型对较难学习的类别样本自信度更低，进一步加剧了参与训练的无标注数据的类别不平衡，这种不公平形成了恶性循环，造成了马太效应，导致模型对较难学习的类别学习效果越来越差，因此FlexMatch提出了对于不同的类别应采用不同的筛选标准，缓解因学习难度不同造成的类别不平衡现象。FlexMatch在FixMatch的基础上改用了动态阈值设置的方法，对较难学习的类别设置更低的自信度阈值，一种最基础的方法为设置一个验证集，根据模型在验证集上各类别的准确率设置阈值，但由于有标注的训练数据本身已较少且在训练过程中不断进行验证更新模型的验证准确率会造成较大的计算开销，因此FlexMatch采用了近似评估类别准确率的方法，首先选取自信度最高的类别作为其样本伪标注，对于每一批次的无标注数据，统计不同类别在该批数据中作为伪标注且自信度大于阈值参数的数量，之后对不同类别的统计数量除以其中的最大值进行归一化作为该类别的分类难度的评估度量，用固定阈值与该类别的分类难度度量相乘即可得到该类别在这一批次无标注数据中应使用的动态阈值。FlexMatch较好地缓解了无标注数据根据自信度进行筛选后由于学习难度不同造成的的类别不平衡问题，且没有因在训练过程中评估模型对不同类别的预测效果产生过多的额外计算时间和存储开销。\n<div align=center>\n<img width=\"1000px\"  src=\"./Imgs/FlexMatch.png\" >\n<br>\n图24[27]：FlexMatch算法\n</div>\n\n### 深度生成式方法\n\n生成式方法利用真实数据对数据分布进行建模，并且可以利用这一分布生成新的数据。不同于经典的生成模型，深度生成式模型基于深度神经网络生成数据。生成对抗网络（GAN）和变分自编码器（VAE）是最常用的生成式模型。\n\n#### ImprovedGAN\n\n生成对抗网络模型分为两个部分：生成器和判别器，其中生成器假设数据可以由产生于某一特定的分布的低维隐变量生成，通过从隐变量分布上随机采样用于生成模拟数据，而生成器是一个分类器，用于判别输入样本是真实数据还是由生成器生成的模拟数据，生成器通过优化要使生成的样本与真实样尽可能接近以欺骗判别器，判别器通过优化要尽可能正确地区分真假样本，避免被生成器欺骗，两者以对抗地方式共同训练，从而达到同时得到较好的生成器与判别器的目的。\n\nSalimans等提出了ImprovedGAN[30] （如图25所示）。经典的GAN模型仅利用无标注数据就可以完成训练，其判别器仅需要判断样本是真实样本还是生成样本。ImprovedGAN加入了对有标注数据的利用，要求判别器不仅要区分样本的真实性，还要完成对样本的分类，即将判别器改为k+1类分类器，其中k是原数据集的类别数量，通过生成器与判别器的交替训练，既可以实现数据生成，又可以完成分类。\n<div align=center>\n<img width=\"500px\"  src=\"./Imgs/ImprovedGAN.png\" >\n<br>\n图25[3]：ImprovedGAN算法\n</div>\n\n#### SSVAE\n\n变分自编码器将深度自编码器融入生成模型，同样假设存在产生于某一特定分布的低维隐变量，将隐变量作为原特征的表示向量，并通过深度神经网络建立隐变量到原特征的映射，作为解码器；由于无法直接求得原始特征到隐变量的后验概率，也需要通过神经网络来近似，作为编码器，学习的目标为做大化原始样本的边缘概率，由于当近似后验分布与真实后验分布相等时， 边缘概率可以达到其上界，因此可以学到与真实后验分布近似的祭祀后验分布，作为编码器可以得到合理的样本表示。\n\nKingma等提出了SSVAE[31]（如图26所示）。经典的VAE模型仅利用无标注数据就可以完成训练，其目标在于通过编码器完成对数据表示的学习，并通过解码器可以实现数据生成。SSVAE加入了对有标注样本的应用，将编码器分为了两个部分，第一部分对原始数据进行编码得到样本软标注的概率分布，第二部分将原始数据与软标注共同作为输入得到隐变量的概率分布。经典VAE模型的编码器仅对数据的表示进行学习，SSVAE的编码器首先可以用样本进行分类，之后可以结合样本信息与类别信息共同学习样本的表示。\n<div align=center>\n<img width=\"300px\"  src=\"./Imgs/SSVAE.png\" >\n<br>\n图26[3]：SSVAE算法\n</div>\n\n### 深度图方法\n\n对于原始数据是图数据的情况，由于实例之间并非独立关系，而是通过边相连，经典的深度学习方法无法有效利用图模型的结构信息，因此无法直接将其应用于图数据。然而，图数据在实际应用中非常常见，研究可以用于图数据的深度学习方法具有重要意义，目前图深度学习已经取得了一定的研究成果。在半监督领域也是如此，经典的半监督学习方法忽略了图的结构信息，因此直接用于图结构数据效果并不理想，现实中的图数据任务往往都是半监督的，即待预测结点与训练节点在一张图上，图中同时存在有标注数据与无标注数据。\n\n#### SDNE\n\nWang等[30]提出了SDNE （如图27所示）。SDNE是一种可以在图中结点没有特征表示，仅有图结构信息的情况下学习图中结点嵌入向量的半监督图深度学习方法。该方法采用了自编码器结构，取结点在邻接矩阵中对应的行作为结点的邻接向量，将结点的邻接向量作为结点的特征输入自编码器，通过编码器得到结点的嵌入表示，通过解码器还原邻接向量，对于整个图，相当于通过自编码器还原了邻接矩阵。SDNE的损失函数主要包含三项：第一项惩罚了自编码器输入与输出的不一致性，使邻自编码器的输入与输出尽可能一致，另外与经典自编码器不同的是，SDNE的输入是邻接向量，由于邻接矩阵的稀疏性，导致输入的特征中存在大量的零值，SDNE指出应该更加关注对于非零值的还原，因此赋予了零值与非零值不同的权重；第二项为拉普拉斯正则，根据图结构信息惩罚了相邻节点间隐层表示的不一致性，并将邻接矩阵作为权重，得到了拉普拉斯正则项；第三项为L2正则，惩罚了自编码器的参数复杂度，以此来避免过拟合。在SDNE方法中，损失函数的第一项更关注结点本身的特征，而第二项更关注相邻节点间的信息，即图的结构信息，有效解决了经典半监督学习算法无法有效利用图结构信息的问题。\n<div align=center>\n<img width=\"300px\"  src=\"./Imgs/SDNE.png\" >\n<br>\n图27[3]：SDNE算法\n</div>\n\n#### GCN\n\nKipf等[31]提出了GCN（如图28所示）。与SDNE使用结点的邻接向量作为结点特征学习嵌入表示不同，GCN更适用于结点本身存在特征的情况，GCN可以同时利用结点本身的特征信息和图结构信息进行学习，显著地提升了模型的效果。在图深度学习中，图神经网络（GNN）[35]是最常用的一类方法，这类方法通常以存在结点特征的图作为输入，可以学习到结点的深层表示，并以此完成学习任务。经典的GNN方法分为两个步骤：第一个步骤为聚集（Aggregate），即通过图结构将近邻结点的信息进行汇集；第二个步骤为更新（Update），即根据结点自身表示与近邻结点更新结点表示。不断重复这两个步骤，可以得到每个结点的深层表示，由于聚集操作存在传播效果，结点的深层表示中不仅涵盖了节点自身信息，还涵盖了图结构信息。经典的聚集操作为线性聚集，即将近邻节点表示的线性组合作为该节点的近邻表示，经典的更新操作为使用感知机模型，由结点自身表示与近邻表示得到新的自身表示。经典的GNN模型存在一定的局限性，其对近邻节点的表示进行线性组合的聚集方式使度较大的结点更大程度地影响了其他节点，而度较小的结点对整个训练过程的影响较小。GCN方法对每一结点将标准化后的近邻表示与自身表示直接相加，并将结果作感知器的输入，得到的结果作为新的自身表示，其中标准化过程将近邻结点与自身结点的表示分别除以一个标准化因子，其中近邻结点的标准化因子为自身结点的度与近邻结点的度的几何平均，自身结点的标准化因子为自身结点的度。GCN在图结构任务上有着优异的表现，并且其更新过程避免了对近邻结点线性组合权重的学习，拥有更少的参数与更高的效率。\n\n<div align=center>\n<img width=\"600px\"  src=\"./Imgs/GCN.png\" >\n<br>\n图28[31]：GCN算法\n</div>\n\n#### GAT\n\nVelickovic等[32]提出了GAT（如图29所示）。GAT[32]和GCN同样适用于结点本身存在特征的情况，不同于GCN的图卷积操作，GAT引入了注意力机制，每次迭代根据当前结点自身的表示和近邻结点的的表示计算注意力权重，并利用权重对当前结点的表示进行更新。\n\n<div align=center>\n\n<img width=\"600px\"  src=\"./Imgs/GAT.png\" >\n\n<br>\n图29[32]：GAT算法\n</div>\n\n# API\n\n## LAMDA_SSL.Algorithm\n\n### LAMDA_SSL.Algorithm.Classifiacation\n\n#### LAMDA_SSL.Algorithm.Classifiacation.Assemble\n\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.Assemble.Assemble(base_model=SVC(probability=True),T=100,alpha=1,beta=0.9)\n> - Parameter:\n>> - base_model: 用于集成学习的基学习器。\n>> - T: 基学习器的数量,也是迭代的轮次。\n>> - alpha: 各样本在采样分布更新时的权重。\n>> - Beta: 用于初始化有标注数据与无标注数据的采样分布。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.Co_Training\n\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.Co_Training.Co_Training(base_estimator, base_estimator_2=None, p=5, n=5, k=30, s=75)\n> - Parameter:\n>> - base_estimator: 用于协同训练的第一个学习器。\n>> - base_estimator_2: 用于协同训练的第二个学习器。\n>> - p: 每一轮每一个基学习器最多选取p个正样本赋予伪标注。\n>> - n: 每一轮每一个基学习器最多选取n个负样本赋予伪标注。\n>> - k: 迭代轮次。\n>> - s: 每一轮迭代中缓冲池的大小。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.FixMatch\n\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.FixMatch.FixMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 parallel=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=5e-4\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 threshold=0.95,\n                 lambda_u=1.0,\n                 mu=1.0,\n                 ema_decay=0.999,\n                 T=0.5)\n> - Parameter:\n>> - threshold: 选择样本的自信度阈值。\n>> - lambda_u: 无监督损失的权重。\n>> - mu: 每一批次无标注数据与有标注数据的比例。\n>> - ema_decay: 指数移动平滑的更新权重。\n>> - T: 标注锐化的温度。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.FlexMatch\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.FlexMatch.FlexMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 threshold=None,\n                 lambda_u=None,\n                 mu=None,\n                 ema_decay=None,\n                 T=None,\n                 num_classes=10,\n                 thresh_warmup=None,\n                 use_hard_labels=False,\n                 use_DA=False,\n                 p_target=None\n                 )\n> - Parameter:\n>> - threshold: 选择样本的自信度阈值。\n>> - lambda_u: 无监督损失的权重。\n>> - ema_decay: 指数移动平滑的更新权重。\n>> - T: 标注锐化的温度。\n>> - num_classes: 分类任务的类别数。\n>> - thresh_warmup: 是否使用Threshold warm-up机制。\n>> - use_hard_labels: 是否再一致性正则中使用硬标注。\n>> - use_DA: 是否对软标注进行分布对齐。\n>> - p_target: 有标注数据的标注分布。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。 \n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.GCN\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.GCN.GCN(\n                 dim_in=1433,\n                 num_classes=7,\n                 dim_hidden=16,\n                 normalize=True,\n                 epoch=1,\n                 eval_epoch=None,\n                 network=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 parallel=None,\n                 file=None,\n                 device='cpu',\n                 evaluation=None\n                 )\n> - Parameter:\n>> - dim_in: 结点特征维度。\n>> - num_classes: 类别数量。\n>> - dim_hidden: 隐层维度。\n>> - normalize: 是否使用对称标准化。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.GAT\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.GAT.GAT(\n                 dim_in=1433,\n                 dim_hidden=16,\n                 dropout=0,\n                 heads=8,\n                 epoch=1,\n                 eval_epoch=None,\n                 network=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 parallel=None,\n                 file=None,\n                 device='cpu',\n                 evaluation=None\n                 )\n> - Parameter:\n>> - dim_in: 结点特征维度。\n>> - num_classes: 类别数量。\n>> - dim_hidden: 隐层维度。\n>> - dropout: dropout概率。\n>> - heads: 注意力机制中头的数量。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.ICT\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.ICT.ICT(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmup=None,\n                 lambda_u=None,\n                 alpha=None)\n> - Parameter:\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - lambda_u: 无监督损失的比例。\n>> - alpha: Mixup中Beta分布的参数。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.ImprovedGAN\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.ImprovedGAN.ImprovedGAN(\n                 train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 epoch=1,\n                 network=None,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=0,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None,\n                 dim_in=(28,28),\n                 num_class=10,\n                 dim_z=500,\n                 hidden_G=[500,500],\n                 hidden_D=[1000,500,250,250,250],\n                 noise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5],\n                 activations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus()],\n                 activations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 lambda_u=1.0,\n                 num_labeled=None)\n> - Parameter:\n>> - dim_in: 输入数据中单个实例的维度.\n>> - num_class: 类别数量。\n>> - dim_z: 用于生成数据的隐变量的维度。\n>> - hidden_G: 作为生成器的神经网络的隐层维度，如果有多个隐层，用列表表示。\n>> - hidden_D: 作为判别器的神经网络的隐层维度，如果有多个隐层，用列表表示。\n>> - noise_level: 判别器每一层的噪声水平。\n>> - activations_G: 生成器每一层的激活函数。\n>> - activations_D: 判别器每一层的激活函数。\n>> - lambda_u: 无监督损失的权重。\n>> - num_labeled: 有标注样本的数量。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classifiacation.LabelPropagation\n> CLASS LAMDA_SSL.Algorithm.Classifiacation.LabelPropagation.LabelPropagation(kernel=\"rbf\",\n        gamma=20,\n        n_neighbors=7,\n        max_iter=30,\n        tol=1e-3,\n        n_jobs=None,\n    )\n> - Parameter:\n>> - kernel: 核函数，可输入字符串'rbf'或'knn'，或以函数形式输入。\n>> - gamma: 当核函数为rbf核时有效。\n>> - n_neighbors: 当核函数为n_neighbors核时有效。\n>> - max_iter: 最大迭代次数。\n>> - tol: 收敛的容忍度。\n>> - n_jobs: 并行的作业数量。\n\n#### LAMDA_SSL.Algorithm.Classification.LabelSpreading\n> CLASS LAMDA_SSL.Algorithm.Classification.LabelSpreading.LabelSpreading(\n        kernel=\"rbf\",\n        gamma=10,\n        n_neighbors=7,\n        alpha=0.2,\n        max_iter=30,\n        tol=1e-3,\n        n_jobs=None)\n> - Parameter:\n>> - kernel: 核函数，可输入字符串'rbf'或'knn'，或以函数形式输入。\n>> - gamma: 当核函数为rbf核时有效。\n>> - n_neighbors: 当核函数为n_neighbors核时有效。\n>> - alpha: 每一轮迭代中的标注更新的比重。\n>> - max_iter: 最大迭代次数。\n>> - tol: 收敛的容忍度。\n>> - n_jobs: 并行的作业数量。\n\n#### LAMDA_SSL.Algorithm.Classification.LadderNetwork\n> CLASS LAMDA_SSL.Algorithm.Classification.LadderNetwork.LadderNetwork(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 epoch=1,\n                 network=None,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None,\n                 dim_in=(28,28),\n                 num_classes=10,\n                 noise_std=0.2,\n                 lambda_u=[0.1, 0.1, 0.1, 0.1, 0.1, 10., 1000.],\n                 encoder_sizes=[1000, 500, 250, 250, 250],\n                 encoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()]\n                 )\n> - Parameter:\n>> - dim_in: 输入数据每一个实例的维度。\n>> - num_classes: 类别数量。\n>> - noise_std: 噪声程度。\n>> - lambda_u: LadderNetwork每一层一致性损失的比重。\n>> - encoder_sizes: 编码器每一层的维度。\n>> - encoder_activations: 编码器每一层的激活函数。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。 \n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.LapSVM\n> CLASS LAMDA_SSL.Algorithm.Classification.LapSVM.LapSVM(\ndistance_function = rbf_kernel,\n           gamma_d=0.01,\n           neighbor_mode =None,\n           n_neighbor= 5,\n           kernel_function= rbf_kernel,\n           gamma_k=0.01,\n           gamma_A= 0.03125,\n           gamma_I= 0)\n> - Parameter:\n>> - distance_function: 用于构图的距离函数，当neighbor_mode为None时有效。\n>> - gamma_d: 与distance_function相关的核参数。\n>> - neighbor_mode: k近邻构图后的边权，有'connectivity'和'distance'两个选项，'connectivity'返回0-1矩阵，'distance'返回距离矩阵。\n>> - n_neighbor: k紧邻中k的值。\n>> - kernel_function: SVM对应的核函数。\n>> - gamma_k: 与kernel_function对应的gamma参数。\n>> - gamma_A: 对函数复杂度的惩罚权重。\n>> - gamma_I: 对数据分布平滑性的惩罚权重。\n\n#### LAMDA_SSL.Algorithm.Classification.MeanTeacher\n> CLASS LAMDA_SSL.Algorithm.Classification.MeanTeacher.MeanTeacher(\ntrain_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 ema_decay=None,\n                 warmup=None,\n                 lambda_u=None)\n> - Parameter:\n>> - ema_decay: 指数移动平均的更新权重。\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - lambda_u: 无监督损失的权重。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.MixMatch.MixMatch\n> CLASS LAMDA_SSL.Algorithm.Classification.MixMatch.MixMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 warmup=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 mu=None,\n                 ema_decay=None,\n                 device='cpu',\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 T=None,\n                 num_classes=10,\n                 alpha=None\n                 )\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - T: 软标注的锐化温度。\n>> - num_classes: 类别数量。\n>> - alpha: Mixup中Beta分布的参数。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.PiModel\n> CLASS LAMDA_SSL.Algorithm.Classification.PiModel.PiModel(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 ema_decay=None,\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 warmup=0.4,\n                 lambda_u=None,\n                 )\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.PseudoLabel\n> CLASS LAMDA_SSL.Algorithm.Classification.PseudoLabel.PseudoLabel(self,train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 warmup=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 ema_decay=None,\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 threshold=0.95\n                 )\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - threshold: 选择样本的自信度阈值。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.ReMixMatch\n> CLASS LAMDA_SSL.Algorithm.Classification.ReMixMatch.ReMixMatch(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 warmup=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 mu=None,\n                 ema_decay=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 T=None,\n                 num_classes=10,\n                 alpha=None,\n                 p_target=None,\n                 lambda_s=None,\n                 lambda_rot=None,\n                 rotate_v_list=None\n                 )\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - T: 锐化温度。\n>> - num_classes: 类别数量。\n>> - alpha: Mixup中的Beta分布的参数。\n>> - p_target: 有标注数据的标注分布。\n>> - lambda_s: 基于Mixup前的数据计算的无监督损失的权重。\n>> - lambda_rot: 旋转角度分类损失的权重。\n>> - rotate_v_list: 旋转角度列表。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.S4L\n> CLASS LAMDA_SSL.Algorithm.Classification.S4L.S4L(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 ema_decay=None,\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 num_classes=10,\n                 p_target=None,\n                 rotate_v_list=None,\n                 labeled_usp=True,\n                 all_rot=True)\n> - Parameter:\n>> - lambda_u: 无监督损失的比重。\n>> - num_classes: 类别数量。\n>> - p_target: 有标注样本的类别分布。\n>> - rotate_v_list: 旋转角度列表。\n>> - labeled_usp: 是否在计算无监督损失时使用有标注数据。\n>> - all_rot: 是否对样本进行rotate_v_list中的所有角度的旋转。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.SDNE\n> CLASS LAMDA_SSL.Algorithm.Classification.SDNE.SDNE(epoch=1,\n                 eval_epoch=None,\n                 optimizer=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 weight_decay=None,\n                 network=None,\n                 parallel=None,\n                 file=None,\n                 xeqs=True,\n                 dim_in=None,\n                 num_nodes=None,\n                 hidden_layers=[250, 250],\n                 alpha=1e-2,\n                 gamma=0.9,\n                 beta=5,\n                 base_estimator=None)\n> - Parameter:\n>> - xeqs: 是否将邻接矩阵作为结点的特征矩阵。\n>> - dim_in: 结点特征维度，xeqs为False时有效。\n>> - num_nodes: 图中结点数量。\n>> - hidden_layers: 编码器隐层维度。\n>> - alpha: 拉普拉斯正则的权重。\n>> - gamma: L2正则的权重。\n>> - beta: 自编码器输入与输出的一致性损失中，图中不为0的边占的权重。\n>> - base_estimator: 用编码器得到的结点特征进行分类的学习器。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n<!-- #### LAMDA_SSL.Algorithm.Classification.Self_training\n> CLASS LAMDA_SSL.Algorithm.Classification.Self_Training.Self_training(base_estimator,\n                threshold=0.75,\n                criterion=\"threshold\",\n                k_best=10,\n                max_iter=10,\n                verbose=False)\n> - Parameter:\n>> - base_estimator: Self_training算法中使用的基监督学习器。\n>> - criterion: 有'threshold'和'k_best'两种形式，前者根据阈值选择样本，后者根据排名选择样本。\n>> - threshold: criterion为'threshold'时，自训练中选择样本使用的阈值。\n>> - k_best: criterion为'k_best'时，自训练中选择自信度前k的样本。\n>> - max_iter: 迭代次数上界。\n>> - verbose: 是否允许冗余输出。 -->\n\n#### LAMDA_SSL.Algorithm.Classification.SemiBoost\n> CLASS LAMDA_SSL.Algorithm.Classification.SemiBoost.SemiBoost(base_estimator =SVC(),\nsimilarity_kernel = 'rbf',\n                        n_neighbors=4, \n                        gamma=0.1, \n                        T = 300,\n                        sample_percent = 0.01,\n                        sigma_percentile = 90,\n                        n_jobs = 1\n                        )\n> - Parameter:\n>> - base_estimator: 算法中使用的基监督学习器。\n>> - similarity_kernel: 算法中使用的核函数，可选'rbf'、'knn'或函数。\n>> - n_neighbors: 核函数为'knn'时有效，表示k近邻中k的值。\n>> - n_jobs: 核函数为'knn'时有效，表示并行作业数量。\n>> - gamma: 核函数为'rbf'时有效，表示rbf核的gamma值。\n>> - T: 集成中最大模型数量。\n>> - sample_percent: 每次迭代采样的样本数量占剩余无标注样本的比例。\n>> - sigma_percentile: 'rbf'核中使用的比例参数。\n\n#### LAMDA_SSL.Algorithm.Classification.SSGMM\n> CLASS LAMDA_SSL.Algorithm.Classification.SSGMM.SSGMM(num_classes, tolerance=1e-8, max_iterations=300)\n> - Parameter:\n>> - num_classes: 类别数量。\n>> - tolerance: 迭代结束的容忍度。\n>> - max_iterations: 最大迭代次数。\n\n#### LAMDA_SSL.Algorithm.Classification.SSVAE\n> CLASS LAMDA_SSL.Algorithm.lassification.SSVAE.SSVAE(\n                 alpha,\n                 dim_in,\n                 num_classes=10,\n                 dim_z=50,\n                 dim_hidden_de=[ 500,500],\n                 dim_hidden_en_y=[ 500,500], dim_hidden_en_z=[ 500,500],\n                 activations_de=[nn.Softplus(), nn.Softplus()],\n                 activations_en_y=[nn.Softplus(), nn.Softplus()],\n                 activations_en_z=[nn.Softplus(), nn.Softplus()],\n                 num_labeled=None,\n                 train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 epoch=1,\n                 network=None,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=0,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None)\n> - Parameter:\n>> - alpha: 分类损失的权重。\n>> - dim_in: 输入样本的维度。\n>> - num_classes: 类别数量。\n>> - dim_z: 隐变量z的维度。\n>> - dim_hidden_de: 解码器隐层维度。\n>> - dim_hidden_en_y: 对于y的编码器的隐层维度。\n>> - dim_hidden_en_z: 对于z的编码器的隐层维度。\n>> - activations_de: 解码器的激活函数。\n>> - activations_en_y: 对于y的编码器的激活函数。\n>> - activations_en_z: 对于z的编码器的激活函数。\n>> - num_labeled: 有标注样本的数量。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.TemporalEnsembling\n> CLASS LAMDA_SSL.Algorithm.Classification.TemporalEnsembling.TemporalEnsembling(valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 mu=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 ema_decay=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 warmup=None,\n                 ema_weight=None,\n                 num_classes=None,\n                 num_samples=None\n                 )\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - ema_weight: 指数移动平滑伪标记的更新权重。\n>> - num_classes: 类别数量。\n>> - num_samples: 训练过程中使用的无标注数据数量。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。 \n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.Tri_Training\n> CLASS LAMDA_SSL.Algorithm.Classification.Tri_Training.Tri_Training(base_estimator,base_estimator_2=None,base_estimator_3=None)\n> - Parameter:\n>> - base_estimator: TriTraining中的第一个基学习器。\n>> - base_estimator_2: TriTraining中的第二个基学习器。\n>> - base_estimator_3: TriTraining中的第三个基学习器。\n\n#### LAMDA_SSL.Algorithm.Classification.TSVM\n> CLASS LAMDA_SSL.Algorithm.Classification.TSVM.TSVM(Cl=1.0,\n            Cu=0.001,\n            kernel=rbf_kernel,\n            degree=3,\n            gamma=\"scale\",\n            shrinking=True,\n            probability=False,\n            tol=1e-3,\n            cache_size=200,\n            class_weight=None,\n            verbose=False,\n            max_iter=-1,\n            decision_function_shape=\"ovr\",\n            break_ties=False,\n            random_state=None)\n> - Parameter:\n>> - Cl: 有标注样本权重。\n>> - Cu: 无标注样本初始权重。\n>> - kernel: 核函数，支持字符串'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'或函数。\n>> - degree: 'poly'核对应的多项式阶数。\n>> - gamma: kernel对应的gamma参数，对于‘rbf’,‘poly’ 和‘sigmoid’有效。\n>> - coef0: 核函数的常数项。对于‘poly’和 ‘sigmoid’有用。\n>> - shrinking: 是否使用shrinking heuristic方法。\n>> - probability: 旋转角度分类损失的权重。\n>> - tol: 停止训练的容忍度大小，默认为1e-3。\n>> - cache_size: 核函数cache缓存大小。\n>> - class_weight: 类别的权重。\n>> - verbose: 是否允许冗余输出。\n>> - max_iter: 最大迭代次数。-1为无限制。\n>> - decision_function_shape: 二分类时忽视，多分类时若为'ovo'，表示1对1分类，各类别两两之间完成分类；若为'ovr'，表示1对多分类，各类别与其他所有类别完成分类。\n>> - break_ties: 发生平局时是否通过计算自信度选择类别。\n>> - random_state: 数据打乱的随机种子。\n\n#### LAMDA_SSL.Algorithm.Classification.UDA\n> CLASS LAMDA_SSL.Algorithm.Classification.UDA.UDA(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 mu=None,\n                 evaluation=None,\n                 ema_decay=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 threshold=0.95,\n                 num_classes=None,\n                 tsa_schedule=None,\n                 T=0.4)\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - threshold: 选择样本的自信度阈值。\n>> - num_classes: 类别数量。\n>> - tsa_schedule: 阈值调整策略，可选'linear'、'exp'或'log'。\n>> - T: 软标注的锐化温度。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Classification.VAT\n> CLASS LAMDA_SSL.Algorithm.Classification.VAT.VAT(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 mu=None,\n                 ema_decay=None,\n                 device='cpu',\n                 evaluation=None,\n                 parallel=None,\n                 file=None,\n                 lambda_u=None,\n                 num_classes=None,\n                 tsa_schedule=None,\n                 eps=6,\n                 warmup=None,\n                 it_vat=1,\n                 xi=1e-6,\n                 lambda_entmin=0.06)\n> - Parameter:\n>> - lambda_u: 无监督损失的权重。\n>> - num_classes: 类别数量。\n>> - tsa_schedule: 阈值调整策略，可选'linear'、'exp'或'log'。\n>> - eps: 噪声程度。\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - it_vat: 幂迭代的迭代次数。\n>> - xi: 初始化扰动变量r时使用的比例参数，$r=\\xi d$，d是随机单位向量 。\n>> - lambda_entmin: 熵最小化损失的权重。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n### LAMDA_SSL.Algorithm.Regression\n\n#### LAMDA_SSL.Algorithm.Regression.CoReg\n> CLASS LAMDA_SSL.Algorithm.Regression.CoReg.CoReg(k1=3, k2=3, p1=2, p2=5, max_iters=100, pool_size=100)\n> - Parameter:\n>> - k1: 第一个基学习器中k近邻的k值。\n>> - k2: 第二个基学习器中k近邻的k值。\n>> - p1: 第一个基学习器中计算距离的阶数。\n>> - p2: 第二个基学习器中计算距离的阶数。\n>> - max_iters: 最大迭代次数。\n>> - pool_size: 缓冲池大小。\n\n#### LAMDA_SSL.Algorithm.Regression.ICTReg\n> CLASS LAMDA_SSL.Algorithm.Regression.ICTReg.ICTReg(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmup=None,\n                 lambda_u=None,\n                 alpha=None,\n                 dim_in=None)\n> - Parameter:\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - lambda_u: 无监督损失的权重。\n>> - alpha: 分类损失的权重。\n>> - dim_in: 输入样本的维度。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Regression.MeanTeacherReg\n> CLASS LAMDA_SSL.Algorithm.Regression.MeanTeacherReg.MeanTeacherReg(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmp=0.4,\n                 lamda_u=0.001,\n                 dim_in=None)\n> - Parameter:\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - lambda_u: 无监督损失的权重。\n>> - dim_in: 输入样本的维度。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。\n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n#### LAMDA_SSL.Algorithm.Regression.PiModelReg\n> CLASS LAMDA_SSL.Algorithm.Regression.PiModelReg.PiModelReg(train_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 train_sampler=None,\n                 train_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 optimizer=None,\n                 weight_decay=None,\n                 scheduler=None,\n                 device='cpu',\n                 evaluation=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 ema_decay=None,\n                 mu=None,\n                 parallel=None,\n                 file=None,\n                 warmp=0.4,\n                 lamda_u=0.001,\n                 dim_in=None)\n> - Parameter:\n>> - warmup: warmup的结束位置。例如num_it_total为100，warmup为0.4，则在前40次迭代中进行warmup。\n>> - lambda_u: 无监督损失的权重。\n>> - dim_in: 输入样本的维度。\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。 \n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n### LAMDA_SSL.Algorithm.Clustering\n#### LAMDA_SSL.Algorithm.Clustering.Constrained_k_means\n> CLASS LAMDA_SSL.Algorithm.Cluster.Constrained_k_means.Constrained_k_means(k, tolerance=1e-7, max_iterations=300)\n> - Parameter:\n>> - k: k-means聚类算法的k值。\n>> - tolerance: 迭代结束的容忍度。\n>> - max_iterations: 最大迭代次数。\n\n#### LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means\n> CLASS LAMDA_SSL.Algorithm.Clustering.Constrained_Seed_k_means.Constrained_Seed_k_means(k, tolerance=0.00001, max_iterations=300)\n> - Parameter:\n>> - k: k-means聚类算法的k值。\n>> - tolerance: 迭代结束的容忍度。\n>> - max_iterations: 最大迭代次数。\n\n## LAMDA_SSL.Augmentation\n\n### LAMDA_SSL.Augmentation.Tabular\n\n#### LAMDA_SSL.Augmentation.Tabular.Noise\n> CLASS LAMDA_SSL.Transform.Noise.Noise(noise_level)\n> - Parameter:\n>> - noise_level: 噪声幅度。\n\n### LAMDA_SSL.Augmentation.Vision\n#### LAMDA_SSL.Augmentation.Vision.AutoContrast\n> CLASS LAMDA_SSL.Transform.AutoContrast.AutoContrast()\n\n#### LAMDA_SSL.Augmentation.Vision.Brightness\n> CLASS LAMDA_SSL.Transform.Brightness.Brightness(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.Color\n> CLASS LAMDA_SSL.Augmentation.Vision.Color.Color(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.Contrast\n> CLASS LAMDA_SSL.Augmentation.Vision.Contrast.Contrast(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.Equalize\n> CLASS LAMDA_SSL.Augmentation.Vision.Equalize.Equalize()\n\n#### LAMDA_SSL.Augmentation.Vision.Identity\n> CLASS LAMDA_SSL.Augmentation.Vision.Identity.Identity()\n\n#### LAMDA_SSL.Augmentation.Vision.Invert\n> CLASS LAMDA_SSL.Augmentation.Vision.Invert.Invert()\n\n#### LAMDA_SSL.Augmentation.Vision.Posterize\n> CLASS LAMDA_SSL.Augmentation.Vision.Posterize.Posterize(min_v,max_v,num_bins,magnitude,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.Rotate\n> CLASS LAMDA_SSL.Augmentation.Vision.Rotate.Rotate(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.Sharpness\n> CLASS LAMDA_SSL.Augmentation.Vision.Sharpness.Sharpness(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.ShearX\n> CLASS LAMDA_SSL.Augmentation.Vision.ShearX.ShearX(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.ShearY\n> CLASS LAMDA_SSL.Augmentation.Vision.ShearY.ShearY(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。\n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.Solarize\n> CLASS LAMDA_SSL.Augmentation.Vision.Solarize.Solarize(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。 \n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.TranslateX\n> CLASS LAMDA_SSL.Augmentation.Vision.TranslateX.TranslateX(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。 \n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.TranslateY\n> CLASS LAMDA_SSL.Augmentation.Vision.TranslateY.TranslateY(min_v=None,max_v=None,num_bins=None,magnitude=None,v=None)\n> - Parameter:\n>> - min_v: 增广幅度最小值。 \n>> - max_v: 增广幅度最大值。\n>> - num_bins: 增广幅度划分的间隔数量。\n>> - magnitude: 增广级别。\n>> - v: 直接指定增广幅度。\n\n#### LAMDA_SSL.Augmentation.Vision.RandomCrop\n> CLASS LAMDA_SSL.Augmentation.Vision.RandomCrop.RandomCrop(padding=None, pad_if_needed=False, fill=0, padding_mode=\"constant\")\n> - Parameter:\n>> - padding: 填充的位置。\n>> - pad_if_needed: 是否在图片小于预期大小时进行填充。\n>> - fill: 用于填充的像素。\n>> - padding_mode: 填充空白值的模式。\n\n#### LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip\n> CLASS LAMDA_SSL.Augmentation.Vision.RandomHorizontalFlip.RandomHorizontalFlip()\n\n#### LAMDA_SSL.Augmentation.Vision.CutoutAbs\n> CLASS LAMDA_SSL.Augmentation.Vision.CutoutAbs.CutoutAbs.CutoutAbs(v,fill,random_v)\n> - Parameter:\n>> - v: 裁剪大小的绝对值。\n>> - fill: 裁剪后的填充值。\n>> - random_v: 是否随机确定裁剪大小。\n\n#### LAMDA_SSL.Augmentation.Vision.Cutout\n> CLASS LAMDA_SSL.Augmentation.Vision.Cutout.Cutout(v,fill,random_v=True)\n> - Parameter:\n>> - v: 裁剪大小的相对值。\n>> - fill: 裁剪后的填充值。\n>> - random_v: 是否随机确定裁剪大小。\n\n#### LAMDA_SSL.Augmentation.Vision.RandAugment\n> CLASS LAMDA_SSL.Augmentation.Vision.RandAugment.RandAugment(n, m, num_bins,random=False,augment_list=None)\n> - Parameter:\n>> - n: 随即增广次数。\n>> - m: 随即增广幅度。\n>> - num_bins: 增广幅度划分。\n>> - random: 是否采用随机增广幅度。\n>> - augment_list: 增广方法和幅度的最小和最大值。\n\n#### LAMDA_SSL.Augmentation.Vision.Mixup\n> CLASS LAMDA_SSL.Transform.Mixup.Mixup(alpha)\n> - Parameter:\n>> - alpha: Beta分布的参数。\n\n#### LAMDA_SSL.Augmentation.Text\n\n#### LAMDA_SSL.Augmentation.Text.RandomDeletion\n> CLASS LAMDA_SSL.Augmentation.Text.RandomDeletion.RandomDeletion(p,tokenizer=None)\n> - Parameter:\n>> - p: 随机删除的比例。\n>> - tokenizer: 分词方法。\n\n<!-- ### LAMDA_SSL.Augmentation.Text.RandomInsertion\n> CLASS LAMDA_SSL.Augmentation.Text.RandomInsertion(n=1,tokenizer=None)\n> - Parameter:\n>> - n: 增加单词的次数。\n>> - tokenizer: 分词方法。 -->\n\n#### LAMDA_SSL.Augmentation.Text.RandomSwap\n> CLASS LAMDA_SSL.Augmentation.Text.RandomSwap.RandomSwap(n=1,tokenizer=None)\n> - Parameter:\n>> - n: 交换单词的次数。\n>> - tokenizer: 分词方法。\n\n#### LAMDA_SSL.Augmentation.Text.TFIDFReplacement\n> CLASS LAMDA_SSL.Augmentation.Text.TFIDFReplacement.TFIDFReplacement(text,p=0.7,tokenizer=None,cache_len=100000)\n> - Parameter:\n>> - text: 文本。\n>> - p: 基本替换概率。\n>> - tokenizer: 分词方法。\n>> - cache_len: 随机数缓冲区大小。\n\n### LAMDA_SSL.Augmentation.Graph\n\n#### LAMDA_SSL.Augmentation.Graph.DropNodes\n\n> CLASS LAMDA_SSL.Augmentation.Graph.DropNodes.DropNodes(num_drop, shuffle=True, random_state=None)\n> - Parameter:\n>> - num_drop: 丢弃结点的数量。\n>> - shuffle: 是否打乱。\n>> - random_stare: 随机状态。\n\n#### LAMDA_SSL.Augmentation.Graph.DropEdges\n> CLASS LAMDA_SSL.Augmentation.Graph.DropEdges.DropEdges(num_drop, shuffle=True, random_state=None)\n> - Parameter:\n>> - num_drop: 丢弃边的数量。\n>> - shuffle: 是否打乱。\n>> - random_stare: 随机状态。\n\n## LAMDA_SSL.Base\n\n### LAMDA_SSL.Base.BaseSampler\n> CLASS LAMDA_SSL.Base.BaseSampler.BaseSampler()\n> - init_sampler(data_source):  通过数据对采样器进行初始化。\n>> - data_source: 待采样数据。\n\n### LAMDA_SSL.Base.BaseOptimizer\n> CLASS LAMDA_SSL.Base.BaseOptimizer.BaseOptimizer(defaults)\n> - Parameter:\n>> - defaults: 包含优化选项默认值的字典。\n>> init_optimizer(params): 将需要优化的参数放入优化器。\n>> - params: 待优化的参数。\n\n### LAMDA_SSL.Base.BaseScheduler\n> CLASS LAMDA_SSL.Base.BaseScheduler(last_epoch=-1, verbose=False)\n> - Parameter:\n>> - last_epoch: 最后一个轮次的索引。\n>> - verbose: 是否输出冗余信息。\n> - init_scheduler(optimizer): 利用优化器初始化调度器。\n>> - optimizer: 模型使用的优化器。\n\n### LAMDA_SSL.Base.LambdaLR\n> CLASS LAMDA_SSL.Base.LambdaLR(lr_lambda, last_epoch=-1,verbose=False)\n> - Parameter:\n>> - lr_lambda: 自定义的学习率调度方法。\n>> - last_epoch: 最后一个轮次的索引。\n>> - verbose: 是否输出冗余信息。\n\n### LAMDA_SSL.Base.TabularMixin\n> CLASS LAMDA_SSL.Base.TabularMixin.TabularMixin():\n> - init_transform: 对数据变换方式进行初始化。\n\n### LAMDA_SSL.Base.VisionMixin\n> CLASS LAMDA_SSL.Base.VisionMixin.VisionMixin(mean=None,std=None):\n> - Parameter:\n>> - mean: 数据集均值。\n>> - std: 数据集方差。\n> - init_transform: 对数据变换方式进行初始化。\n\n### LAMDA_SSL.Base.TextMixin\n> CLASS LAMDA_SSL.Base.TextMixin.TextMixin(word_vocab=None,vectors=None,length=300,unk_token='<unk>',pad_token='<pad>',\n                 min_freq=1,special_first=True,default_index=None):\n> - Parameter:\n>> - word_vocab:  将单词转变为下标的映射表。\n>> - vectors: 词向量。\n>> - length: 句长。\n>> - unk_token: 用于表示未知单词的token。\n>> - pad_token: 用于表示填充的token。\n>> - min_freq: 当word_vocab为None，需要构建映射表时，单词可作为token的最低出现频率要求。\n>> - special_first: 是否将特殊字符放在映射表最前面。\n>> - default_index: 将单词转变为下标时如果无法转变应使用的默认值。\n\n### LAMDA_SSL.Base.GraphMixin\n> CLASS LAMDA_SSL.Base.GraphMixin.GraphMixin()\n> - init_transform: 对数据变换方式进行初始化。\n\n### LAMDA_SSL.Base.DeepModelMixin\n> CLASS LAMDA_SSL.Base.DeepModelMixin.DeepModelMixin(train_dataset=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None,\n                 valid_dataset=None,\n                 test_dataset=None,\n                 train_dataloader=None,\n                 labeled_dataloader=None,\n                 unlabeled_dataloader=None,\n                 valid_dataloader=None,\n                 test_dataloader=None,\n                 augmentation=None,\n                 network=None,\n                 epoch=1,\n                 num_it_epoch=None,\n                 num_it_total=None,\n                 eval_epoch=None,\n                 eval_it=None,\n                 mu=None,\n                 optimizer=None,\n                 weight_decay=5e-4,\n                 ema_decay=None,\n                 scheduler=None,\n                 device=None,\n                 evaluation=None,\n                 train_sampler=None,\n                 labeled_sampler=None,\n                 unlabeled_sampler=None,\n                 train_batch_sampler=None,\n                 labeled_batch_sampler=None,\n                 unlabeled_batch_sampler=None,\n                 valid_sampler=None,\n                 valid_batch_sampler=None,\n                 test_sampler=None,\n                 test_batch_sampler=None,\n                 parallel=None,\n                 file=None)\n> - Parameter:\n>> - train_dataset: 训练数据的数据管理器。\n>> - labeled_dataset: 有标注数据的数据管理器。\n>> - unlabeled_dataset: 无标注数据的数据管理器。\n>> - valid_dataset: 验证数据的数据管理器。\n>> - test_dataset: 测试数据的数据管理器。\n>> - augmentation: 增广方法，如果有多种增广方式，可以用字典或列表传参。\n>> - network: 使用的骨干神经网络。\n>> - epoch: 训练轮次数量。\n>> - num_it_epoch: 每一轮次的迭代的数量，即数据的批数。\n>> - num_it_total: 总batch数量。\n>> - eval_epoch: 每隔eval_epoch个epoch进行一次模型效果验证。\n>> - eval_it: 每隔eval_it次迭代进行一次模型效果验证。\n>> - mu: 无标注数据数量与有标注数据数量的比值。\n>> - optimizer: 训练中使用的优化器。\n>> - weight_decay: 优化器的学习率衰减参数。\n>> - ema_decay: 模型参数指数移动平滑的更新比例。\n>> - scheduler: 学习率调度器。\n>> - device: 训练设备。\n>> - evaluation: 模型评估指标，如果有多项指标，可以使用字典或列表。\n>> - train_sampler: 训练数据采样器。\n>> - labeled_sampler=None: 有标注数据采样器。\n>> - unlabeled_sampler=None: 无标注数据采样器。\n>> - train_batch_sampler=None: 训练数据批采样器。\n>> - labeled_batch_sampler: 有标注数据批采样器。\n>> - unlabeled_batch_sampler: 无标注数据批采样器。\n>> - valid_sampler: 验证数据采样器。\n>> - valid_batch_sampler: 验证数据批采样器。 \n>> - test_sampler: 测试数据采样器。\n>> - test_batch_sampler: 测试数据批采样器。\n>> - parallel: 分布式训练方式。\n>> - file: 输出文件。\n\n### LAMDA_SSL.SemiEstimator.SemiEstimator\n> CLASS LAMDA_SSL.Base.SemiEstimator.SemiEstimator()\n> - fit(X,y,unlabeled_X): 进行半监督学习模型训练。\n>> - X: 有标注数据的样本。\n>> - y: 有标注数据的标注。\n>> - unlabeled_X: 无标注数据的样本。\n\n### LAMDA_SSL.InductiveEstimator.InductiveEstimator\n> CLASS LAMDA_SSL.Base.InductiveEstimator.InductiveEstimator()\n> - predict(X): 对待预测数据进行预测。\n>> - X: 待预测的样本。\n\n### LAMDA_SSL.TransductiveEstimator.TransductiveEstimator\n> CLASS LAMDA_SSL.Base.TransductiveEstimator.TransductiveEstimator()\n> - predict(X=None,Transductive=True): 输出直推学习的结果或对待预测数据进行预测。\n>> - X: 待预测的样本，仅在Transductive为False时有效。\n>> - Transductive: 是否使用直推学习机制，直接输出fit时输入的unlabeled_X的预测结果。\n\n### LAMDA_SSL.Base.ClassifierEvaluation\n> CLASS LAMDA_SSL.Base.ClassifierEvaluation.ClassifierEvaluation()\n> - scoring(y_true,y_pred=None,y_score=None): 对模型进行评分。\n>> - y_true: 真实的样本标注。\n>> - y_pred: 模型预测结果的硬标注。\n>> - y_score: 模型预测结果的软标注。\n\n### LAMDA_SSL.Base.RegressorEvaluation\n> CLASS LAMDA_SSL.Base.RegressorEvaluation.RegressorEvaluation()\n> - scoring(y_true,y_pred=None): 对模型进行评分。\n>> - y_true: 真实标注。\n>> - y_pred: 模型预测结果。\n\n### LAMDA_SSL.Base.ClusterEvaluation\n> CLASS LAMDA_SSL.Base.ClusterEvaluation.ClusterEvaluation()\n> - scoring(y_true=None,clusters=None,X=None): 对模型进行评分。\n>> - y_true: 真实标注。\n>> - clusters: 聚类结果。\n>> - X: 聚类时使用的样本特征。\n\n### LAMDA_SSL.Base.Transformer\n> CLASS LAMDA_SSL.Base.Transformer.Transformer()\n> - fit(X,y=None): 通过已有数据获取处理方式。\n>> - X: 用于学习处理方式的样本。\n>> - y: 用于学习处理方式的标注.\n> - transform(X): 对新的数据进行处理。\n>> - X: 待转换的数据。\n> - fit_transform(X,y=None): 首先对已有数据和标注X和y进行fit()再直接对y进行转换。\n>> - X: 用于学习和转换的样本。\n>> - y: 用于学习的标注。\n\n## LAMDA_SSL.Dataloader\n\n### LAMDA_SSL.DataLoader.LabeledDataLoader\n\n> CLASS LAMDA_SSL.DataLoader.LabeledDataLoader.LabeledDataLoader(batch_size= 1, shuffle: bool = False,\n                 sampler = None, batch_sampler= None,\n                 num_workers: int = 0, collate_fn= None,\n                 pin_memory: bool = False, drop_last: bool = False,\n                 timeout: float = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor: int = 2, persistent_workers: bool = False)\n> - Parameter:\n>> - batch_size: 每一批数据的数量。\n>> - shuffle: 是否对数据进行洗牌。\n>> - sampler: 加载时使用的采样器。\n>> - batch_sampler: 加载时使用的批采样器。\n>> - num_workers: 数据加载时使用的子进程数量。\n>> - collate_fn: 将列表中的样本转变为Tensor的方法。\n>> - pin_memory: 如果为“True”，数据加载器将在返回之前将张量复制到 CUDA 固定内存中。\n>> - drop_last: 对于冗余的不够一批次的数据是否丢除。\n>> - timeout: 收集一批次数据的超时值。\n>> - worker_init_fn: 如果不是None，将在每个工作子进程上调用的函数。\n>> - multiprocessing_context: 多进程上下文。\n>> - generator: 如果不是None，采样器为RandomSampler时用来生成随机索引。\n>> - prefetch_factor: 每个进程预先加载的样本数。\n>> - persistent_workers: 如果为“True”，数据加载器将不会在数据集被使用一次后关闭工作进程。 这允许维持工作人员的“数据集”实例处于活动状态。\n\n### LAMDA_SSL.DataLoader.TrainDataLoader\n\n> CLASS LAMDA_SSL.DataLoader.TrainDataLoader.TrainDataLoader(\nbatch_size=1,\n                 shuffle = False, sampler = None,\n                 batch_sampler=None, Iterable = None,\n                 num_workers = 0, collate_fn = None,\n                 pin_memory = False, drop_last = True,\n                 timeout = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor = 2,\n                 persistent_workers= False,\n                 batch_size_adjust=False,labeled_dataloader=None,unlabeled_dataloader=None)\n> - Parameter:\n>> - batch_size: 每一批数据的数量。\n>> - shuffle: 是否对数据进行洗牌。\n>> - sampler: 加载时使用的采样器。\n>> - batch_sampler: 加载时使用的批采样器。\n>> - num_workers: 数据加载时使用的子进程数量。\n>> - collate_fn: 将列表中的样本转变为Tensor的方法。\n>> - pin_memory: 如果为“True”，数据加载器将在返回之前将张量复制到 CUDA 固定内存中。\n>> - drop_last: 对于冗余的不够一批次的数据是否丢除。\n>> - timeout: 收集一批次数据的超时值。\n>> - worker_init_fn: 如果不是None，将在每个工作子进程上调用的函数。\n>> - multiprocessing_context: 多进程上下文。\n>> - generator: 如果不是None，采样器为RandomSampler时用来生成随机索引。\n>> - prefetch_factor: 每个进程预先加载的样本数。\n>> - persistent_workers: 如果为“True”，数据加载器将不会在数据集被使用一次后关闭工作进程。 这允许维持工作人员的“数据集”实例处于活动状态。\n>> - batch_size_adjust: 是否根据无标注样本与有标注样本的比例自动调整labeled_dataloader和unlabeled_dataloader的batch_size的大小。\n>> - labeled_dataloader: 有标注数据的加载器。\n>> - unlabeled_dataloader: 无标注数据的加载器。\n\n### LAMDA_SSL.DataLoader.UnlabeledDataLoader\n\n> CLASS LAMDA_SSL.DataLoader.UnlabeledDataLoader.UnlabeledDataLoader(batch_size= 1,\n                 shuffle: bool = False, sampler = None,\n                 batch_sampler= None,\n                 num_workers: int = 0, collate_fn= None,\n                 pin_memory: bool = False, drop_last: bool = False,\n                 timeout: float = 0, worker_init_fn = None,\n                 multiprocessing_context=None, generator=None,\n                 prefetch_factor: int = 2,\n                 persistent_workers: bool = False)\n> - Parameter:\n>> - batch_size: 每一批数据的数量。\n>> - shuffle: 是否对数据进行洗牌。\n>> - sampler: 加载时使用的采样器。\n>> - batch_sampler: 加载时使用的批采样器。\n>> - num_workers: 数据加载时使用的子进程数量。\n>> - collate_fn: 将列表中的样本转变为Tensor的方法。\n>> - pin_memory: 如果为“True”，数据加载器将在返回之前将张量复制到 CUDA 固定内存中。\n>> - drop_last: 对于冗余的不够一批次的数据是否丢除。\n>> - timeout: 收集一批次数据的超时值。\n>> - worker_init_fn: 如果不是None，将在每个工作子进程上调用的函数。\n>> - multiprocessing_context: 多进程上下文。\n>> - generator: 如果不是None，采样器为RandomSampler时用来生成随机索引。\n>> - prefetch_factor: 每个进程预先加载的样本数。\n>> - persistent_workers: 如果为“True”，数据加载器将不会在数据集被使用一次后关闭工作进程。 这允许维持工作人员的“数据集”实例处于活动状态。\n\n## LAMDA_SSL.Dataset\n\n### LAMDA_SSL.Dataset.LabeledDataset\n\n> CLASS LAMDA_SSL.Dataset.LabeledDataset.LabeledDataset(transforms=None, transform=None, target_transform=None, pre_transform=None)\n> - Parameter:\n>> - pre_transform: 在增广前对X进行预处理的方式。\n>> - transforms: 在数据增广后同时对X和y进行变换的方式。\n>> - transform: 在数据增广后对X进行变换的方式。\n>> - target_transform: 在数据增广后对y进行变换的方式。\n\n### LAMDA_SSL.Dataset.UnlabeledDataset\n\n> CLASS LAMDA_SSL.Dataset.UnlabeledDataset.UnlabeledDataset(transforms=None, transform=None, target_transform=None, pre_transform=None)\n> - Parameter:\n>> - pre_transform: 在增广前对X进行预处理的方式。\n>> - transform: 在数据增广后对X进行变换的方式。\n\n### LAMDA_SSL.Dataset.TrainDataset\n\n> CLASS LAMDA_SSL.Dataset.TrainDataset.TrainDataset(transforms=None,\n                 transform=None,\n                 pre_transform=None,\n                 target_transform=None,\n                 unlabeled_transform=None,\n                 labeled_size=None,\n                 stratified=False,\n                 shuffle=True,\n                 random_state=None,\n                 labeled_dataset=None,\n                 unlabeled_dataset=None\n                 )\n> - Parameter:\n>> - pre_transform: 在增广前对X进行预处理的方式。\n>> - transforms: 在数据增广后同时对X和y进行变换的方式。\n>> - transform: 在数据增广后对X进行变换的方式。\n>> - target_transform: 在数据增广后对y进行变换的方式。\n>> - unlabeled_transform: 在增广后对unlabeled_X进行处理的方式。\n>> - labeled_size: 有标注样本的个数或比例。\n>> - stratified: 是否按类别比例采样。\n>> - shuffle: 是否对数据进行洗牌。\n>> - random_state: 随机种子。\n>> - labeled_dataset: 有标注数据集。\n>> - unlabeled_dataset: 无标注数据集。\n\n### LAMDA_SSL.Dataset.SemiDataset\n\n> CLASS LAMDA_SSL.Dataset.SemiDataset.SemiDataset(transforms=None,\n                 transform=None,\n                 pre_transform=None,\n                 target_transform=None,\n                 unlabeled_transform=None,\n                 valid_transform=None,\n                 test_transform=None,\n                 test_size=None,\n                 valid_size=None,\n                 labeled_size=None,\n                 stratified=False,\n                 shuffle=True,\n                 random_state=None):\n> - Parameter:\n>> - pre_transform: 在增广前对X进行预处理的方式。\n>> - transforms: 在数据增广后同时对X和y进行变换的方式。\n>> - transform: 在数据增广后对X进行变换的方式。\n>> - target_transform: 在数据增广后对y进行变换的方式。\n>> - unlabeled_transform: 在增广后对unlabeled_X进行处理的方式。\n>> - valid_transform: 在增广后对验证数据的X进行处理的方式。\n>> - test_transform: 在增广后对测试数据的X进行处理的方式。\n>> - test_size: 测试样本的个数或比例。\n>> - valid_size: 验证样本的个数或比例。\n>> - labeled_size: 有标注样本的个数或比例。\n>> - stratified: 是否按类别比例采样。\n>> - shuffle: 是否对数据进行洗牌。\n>> - random_state: 随机种子。\n\n## LAMDA_SSL.Distributed\n\n### LAMDA_SSL.Distributed.DataParallel\n> CLASS LAMDA_SSL.Distributed.DataParallel.DataParallel(device_ids=None, output_device=None, dim=0)\n> - Parameter:\n>> - device_ids: 可使用的gpu卡号。\n>> - output_device: 模型输出结果存放的卡号。\n>> - dim: 各设备上数据聚集的维度。\n\n### LAMDA_SSL.Distributed.DistributedDataParallel\n> CLASS LAMDA_SSL.Distributed.DistributedDataParallel.DistributedDataParallel(device_ids=None,\n        output_device=None,\n        dim=0,\n        broadcast_buffers=True,\n        process_group=None,\n        bucket_cap_mb=25,\n        find_unused_parameters=False,\n        gradient_as_bucket_view=False)\n> - Parameter:\n>> - device_ids: 可使用的gpu卡号。\n>> - output_device: 模型输出结果存放的卡号。\n>> - dim: 各设备上数据聚集的维度。\n>> - broadcast_buffers: 是否在“forward”函数开始时启用模块的同步缓冲区。\n>> - process_group: 用于分布式数据全归约的进程组。 如果为“None”，将使用由torch.distributed.init_process_group 创建的默认进程组。\n>> - bucket_cap_mb: DistributedDataParallel将参数分到多个桶中，以便每个桶中参数的梯度减少与反向传播计算重叠。\n>> - find_unused_parameters: 是否对forward函数返回的Tensor遍历autograd图，并简化没有被用到的参数。\n>> - gradient_as_bucket_view: 梯度是否是指向'allreduce' 通信桶的不同偏移量的视图。\n\n\n## LAMDA_SSL.Evaluation\n\n### LAMDA_SSL.Evaluation.Classifier\n\n#### LAMDA_SSL.Evaluation.Classifier.Accuracy\n> CLASS LAMDA_SSL.Evaluation.Classifier.Accuracy.Accuracy(normalize=True, sample_weight=None)\n> - Parameter:\n>> - normalize: 如果为False，返回正确分类的样本数量。\n>> - sample_weight: 样本权重。\n\n#### LAMDA_SSL.Evaluation.Classifier.Recall\n> CLASS LAMDA_SSL.Evaluation.Classifier.Recall.Recall(labels=None,\n                 pos_label=1,\n                 average=\"binary\",\n                 sample_weight=None,\n                 zero_division=\"warn\")\n> - Parameter:\n>> - labels: 包含的标注集合。\n>> - pos_label: 二分类时的正类标注。\n>> - average: 多分类时的计算方法，可选'micro', 'macro', 'samples', 'weighted', 'binary'。\n>> - sample_weight: 样本权重。\n>> - zero_division: 分母为0时的返回值。\n\n#### LAMDA_SSL.Evaluation.Classifier.Precision\n> CLASS LAMDA_SSL.Evaluation.Classifier.Precision.Precision(labels=None,\n                pos_label=1,\n                average=\"binary\",\n                sample_weight=None,\n                zero_division=\"warn\")\n> - Parameter:\n>> - labels: 包含的标注集合。\n>> - pos_label: 二分类时的正类标注。\n>> - average: 多分类时的计算方法，可选'micro', 'macro', 'samples', 'weighted', 'binary'。\n>> - sample_weight: 样本权重。\n>> - zero_division: 分母为0时的返回值。\n\n#### LAMDA_SSL.Evaluation.Classifier.Top_k_Accurary\n> CLASS LAMDA_SSL.Evaluation.Classification.Top_k_Accurary.Top_k_Accurary(k=2, normalize=True, sample_weight=None, labels=None)\n> - Parameter:\n>> - k: k的取值。\n>> - normalize: 如果为False，返回正确分类的样本数量。\n>> - sample_weight: 样本权重。\n>> - labels: 包含的标注集合。\n\n#### LAMDA_SSL.Evaluation.Classifier.AUC\n> CLASS LAMDA_SSL.Evaluation.Classifier.AUC.AUC(average=\"macro\",\n                 sample_weight=None,\n                 max_fpr=None,\n                 multi_class=\"raise\",\n                 labels=None)\n> - Parameter:\n>> - average: 计算AUC均值的方式，可选'micro', 'macro', 'samples', 'weighted'或None。\n>> - sample_weight: 样本权重。\n>> - max_fpr: 当只计算部分AUC时用于确定范围。\n>> - multi_class: 处理多分类的方法，可选'raise', 'ovr', 'ovo'。\n>> - labels: 包含的标注集合。\n\n#### LAMDA_SSL.Evaluation.Classifier.F1\n> CLASS LAMDA_SSL.Evaluation.Classifier.F1.F1(\nlabels=None,\n                 pos_label=1,\n                 average=\"binary\",\n                 sample_weight=None,\n                 zero_division=\"warn\")\n> - Parameter:\n>> - labels: 包含的标注集合。\n>> - pos_label: 二分类时的正类标注。\n>> - average: 多分类时的计算方法，可选'micro', 'macro', 'samples', 'weighted', 'binary'。\n>> - sample_weight: 样本权重。\n>> - zero_division: 分母为0时的返回值。\n\n### LAMDA_SSL.Evaluation.Regressor\n\n#### LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Mean_Absolute_Error.Mean_Absolute_Error(sample_weight=None, multioutput=\"uniform_average\")\n> - Parameter:\n>> - sample_weight: 样本权重。\n>> - multioutput: 对于多个输出的聚合方法。\n\n#### LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Error.Mean_Squared_Error(sample_weight=None, multioutput=\"uniform_average\",squared=True)\n> - Parameter:\n>> - sample_weight: 样本权重。\n>> - multioutput: 对于多个输出的聚合方法。\n>> - squared: 如果是True，输出MSE损失，否则输出RMSE损失。\n\n\n#### LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error\n> CLASS LAMDA_SSL.Evaluation.Regressor.Mean_Squared_Log_Error.Mean_Squared_Log_Error(sample_weight=None, multioutput=\"uniform_average\")\n> - Parameter:\n>> - sample_weight: 样本权重。\n>> - multioutput: 对于多个输出的聚合方法。\n>> - squared: 如果是True，输出MSLE损失，否则输出RMSLE损失。\n\n### LAMDA_SSL.Evaluation.Cluster\n\n#### LAMDA_SSL.Evaluation.Cluster.Davies_Bouldin_Score\n> CLASS LAMDA_SSL.Evaluation.Davies_Bouldin_Score.Davies_Bouldin_Score()\n\n#### LAMDA_SSL.Evaluation.Cluster.Fowlkes_Mallows_Score\n> CLASS LAMDA_SSL.Evaluation.Fowlkes_Mallows_Score.Fowlkes_Mallows_Score(sparse=False)\n> - Parameter:\n>> - sparse: 是否使用稀疏矩阵进行计算\n\n#### LAMDA_SSL.Evaluation.Cluster.Rand_Score\n> CLASS LAMDA_SSL.Evaluation.Rand_Score.Rand_Score()\n\n#### LAMDA_SSL.Evaluation.Cluster.Jaccard_Score\n> CLASS LAMDA_SSL.Evaluation.Jaccard_Score.Jaccard_Score(labels=None, pos_label=1,average=\"binary\",sample_weight=None,zero_division=\"warn\")\n> - Parameter:\n>> - labels: 包含的标注集合。\n>> - pos_label: 二分类时的正类标注。\n>> - average: 多分类时的计算方法，可选'micro', 'macro', 'samples', 'weighted', 'binary'。\n>> - sample_weight: 样本权重。\n>> - zero_division: 分母为0时的返回值。\n\n#### LAMDA_SSL.Evaluation.Cluster.Silhouette_Score\n> CLASS LAMDA_SSL.Evaluation.Silhouette_Score.Silhouette_Score(metric=\"euclidean\", sample_size=None, random_state=None)\n> - Parameter:\n>> - metric : 用于计算实例间距离的指标.\n>> - sample_size: 采样大小。\n>> - random_state: 随机状态。\n\n## LAMDA_SSL.Loss\n### LAMDA_SSL.LOSS.Consistency\n> CLASS LAMDA_SSL.LOSS.Consistency.LOSS.Consistency.Consistency(reduction='mean',activation_1=None,activation_2=None)\n>> Parameter\n>> - reduction: 对输出的处理方式。\n>> forward(logits_1,logits_2): 进行损失计算。\n>> - logits_1: 计算一致性的第一个输入。\n>> - logits_2: 计算一致性的第二个输入。\n\n### LAMDA_SSL.LOSS.Cross_Entropy\n> CLASS LAMDA_SSL.LOSS.Cross_Entropy.Cross_Entropy(use_hard_labels=True, reduction='none')\n> - Parameter:\n>> - use_hard_labels: 目标是否为硬标注。\n>> - reduction: 对输出的处理方式。\n> - forward(logits, targets): 进行损失计算。\n>> - logits: 模型输出的结果。\n>> - targets: 目标结果。\n\n### LAMDA_SSL.LOSS.KL_Divergence\n> CLASS LAMDA_SSL.LOSS.KL_Divergence.KL_Divergence(softmax_1=True, softmax_2=True)\n> - Parameter:\n>> - softmax_1: 是否对第一个输入进行softmax。\n>> - softmax_2: 是否对第二个输入进行softmax。\n> - forward(logits_1,logits_2): 进行损失计算。\n>> - logits_1: 第一个输入。\n>> - logits_2: 第二个输入。\n\n### LAMDA_SSL.LOSS.MSE\n> CLASS LAMDA_SSL.LOSS.MSE.MSE(reduction='mean',activation_1=None,activation_2=None)\n> - Parameter:\n>> - reduction: 对输出的处理方式。\n>> - activation_1: 对于第一个输入进行处理的激活函数。\n>> - activation_2: 对于第二个输入进行处理的激活函数。\n> - forward(logits_1,logits_2): 进行损失计算。\n>> - logits_1: 第一个输入。\n>> - logits_2: 第二个输入。\n\n### LAMDA_SSL.LOSS.EntMin\n> CLASS LAMDA_SSL.LOSS.EntMin.EntMin(reduction='mean', activation=None)\n> - Parameter:\n>> - reduction: 对输出的处理方式。\n>> - activation: 对于处理logits的激活函数。\n> - forward(logits): 进行损失计算。\n>> - logits: 模型输出的结果。\n\n### LAMDA_SSL.LOSS.Semi_Supervised_Loss\n> CLASS LAMDA_SSL.LOSS.Semi_Supervised_Loss.Semi_Supervised_Loss(lambda_u)\n> - Parameter:\n>> - lambda_u: 无监督算是的权重。\n> - forward(sup_loss,unsup_loss): 进行损失计算。\n>> - sup_loss: 监督损失。\n>> - unsup_loss: 无监督损失。\n\n## LAMDA_SSL.Network\n\n### LAMDA_SSL.Network.GAT\n> CLASS LAMDA_SSL.Network.GAT.GAT(dim_in,num_classes, dim_hidden=16,  heads=8, dropout=0.6)\n> - Parameter:\n>> - dim_in: 特征维度。\n>> - dim_hidden: 隐层维度。\n>> - num_classes: 类别数量。\n>> - heads: 注意力机制中头的数量。\n>> - dropout: dropout概率。\n\n### LAMDA_SSL.Network.GCN\n> CLASS LAMDA_SSL.Network.GCN.GCN(dim_in,num_classes,dim_hidden=16,normalize=False)\n> - Parameter:\n>> - dim_in: 特征维度。\n>> - num_classes: 类别数量。\n>> - dim_hidden: 隐层维度。\n>> - normalize: 是否添加自环并即时计算对称归一化系数。\n\n### LAMDA_SSL.Network.ImprovedGAN\n\n> CLASS LAMDA_SSL.Network.ImprovedGAN.ImprovedGAN\n(G=None, D=None,dim_in = 28 ** 2,\n                 hidden_G=[1000,500,250,250,250],\n                 hidden_D=[1000,500,250,250,250],\n                 noise_level=[0.3, 0.5, 0.5, 0.5, 0.5, 0.5],\n                 activations_G=[nn.Softplus(), nn.Softplus(), nn.Softplus(),nn.Softplus(), nn.Softplus(), nn.Softplus()],\n                 activations_D=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 output_dim = 10,z_dim=100,device='cpu')\n> - Parameter:\n>> - G: 生成器网络。\n>> - D: 判别器网络。\n>> - dim_in: 输入的样本维度。\n>> - hidden_G: 生成器的隐层维度。\n>> - hidden_D: 判别器的隐层维度。\n>> - noise_level: 每一层的噪声级别。\n>> - activations_G: 生成器每一层的激活函数。\n>> - activations_D: 判别器每一层的激活函数。\n>> - output_dim: 输出维度。\n>> - z_dim: 用于生成数据的隐变量维度。\n>> - device: 训练模型的设备。\n\n### LAMDA_SSL.Network.LadderNetwork\n\n> CLASS LAMDA_SSL.Network.LadderNetwork.LadderNetwork\n(encoder_sizes=[1000, 500, 250, 250, 250],\n                 encoder_activations=[nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU(), nn.ReLU()],\n                 noise_std=0.2,dim_in=28*28,num_classes=10,device='cpu')\n> - Parameter:\n>> - encoder_sizes: 生成器网络。\n>> - encoder_activations: 编码器的激活函数。\n>> - noise_std: 噪声的方差。\n>> - dim_in: 样本输入的维度。\n>> - num_classes: 类别数量。\n>> - device: 设备。\n\n### LAMDA_SSL.Network.MLPReg\n\n> CLASS LAMDA_SSL.Network.MLPReg.MLPReg(dim_in = 28 ** 2,hidden_dim=[10],activations=[nn.ReLU()])\n> - Parameter:\n>> - dim_in: 输入样本维度。\n>> - hidden_dim: 隐层维度。\n>> - activations: 隐层使用的激活函数。\n\n### LAMDA_SSL.Network.ResNet50\n\n> CLASS LAMDA_SSL.Network.ResNet50.ResNet50(block= Bottleneck,\n            layers = [3, 4, 6, 3],\n            num_classes = 1000,\n            zero_init_residual= False,\n            groups = 1,\n            width_per_group = 64,\n            replace_stride_with_dilation = None,\n            norm_layer = None)\n> - Parameter:\n>> - block: 基本网络模块。\n>> - layers: 隐层为64、128、256、512维的模块的重复次数。\n>> - num_classes: 类别数量。\n>> - zero_init_residual: 是否用0初始化residual。\n>> - groups: 并行计算的组数。\n>> - width_per_group: 每个组内的卷积核个数\n>> - replace_stride_with_dilation: 含3个bool变量的列表或元组，针对64、128、256维的模块是否进行卷积扩张。\n>> - norm_layer: 正则化方法，默认为BatchNorm2d。\n\n### LAMDA_SSL.Network.SDNE\n> CLASS LAMDA_SSL.Network.SDNE.SDNE(dim_in, hidden_layers, device=\"cpu\")\n> - Parameter:\n>> - dim_in: 输入样本维度。\n>> - hidden_layers: 隐层维度。\n>> - device: 设备。\n\n### LAMDA_SSL.Network.SSVAE\n> CLASS LAMDA_SSL.Network.SSVAE.SSVAE(dim_in,num_classes,dim_z,dim_hidden_de=[500,500],\n                 dim_hidden_en_y=[500,500],dim_hidden_en_z=[500,500],\n                 activations_de=[nn.Softplus(),nn.Softplus()],\n                 activations_en_y=[nn.Softplus(),nn.Softplus()],\n                 activations_en_z=[nn.Softplus(),nn.Softplus()],\n                 device='cpu')\n> - Parameter:\n>> - dim_in: 样本输入维度。\n>> - num_classes: 类别数量。\n>> - dim_z: 隐变量的维度。\n>> - dim_hidden_de: 解码器隐层维度。\n>> - dim_hidden_en_y: 对于y的编码器的隐层维度。\n>> - dim_hidden_en_z: 对于z的编码器的隐层维度。\n>> - activations_de: 解码器各层的激活函数。\n>> - activations_en_y: 对于y的编码器的激活函数。\n>> - activations_en_z: 对于z的编码器的激活函数。\n>> - device: 设备。\n\n### LAMDA_SSL.Network.TextRCNN\n> CLASS LAMDA_SSL.Network.TextRCNN.TextRCNN(n_vocab,embedding_dim=300,len_seq=300, padding_idx=None, hidden_size=256, num_layers=1,\n                 dropout=0.0, pretrained_embeddings=None,num_class=2)\n> - Parameter:\n>> - n_vocab: 字典大小。\n>> - embedding_dim: 词嵌入维度。\n>> - len_seq: 句长。\n>> - padding_idx: 填充值的坐标，不会对梯度产生影响，也不会被更新。\n>> - hidden_size: 隐层的维度。\n>> - num_layers: 网络层数。\n>> - dropout: 神经元丢弃率。\n>> - pretrained_embeddings: 预训练的词嵌入。\n\n### LAMDA_SSL.Network.WideResNet\n> CLASS LAMDA_SSL.Network.WideResNet.WideResNet(num_classes=10, depth=28, widen_factor=2, drop_rate=0.0)\n> - Parameter:\n>> - num_classes: 类别数量。\n>> - depth: 网络深度。\n>> - widen_factor: 网络宽度，用于确定隐层维度。\n>> - dropout: 神经元丢弃率。\n\n## LAMDA_SSL.Optimizer\n\n### LAMDA_SSL.Optimizer.Adam\n> CLASS LAMDA_SSL.Optimizer.Adam.Adam(lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, amsgrad=False)\n> - Parameter:\n>> - lr: 初始学习率。\n>> - betas: 用于计算梯度平均值及其平方的的系数。\n>> - eps: 添加到分母以提高数值稳定性的项。\n>> - weight_decay: L2正则对应的权重。\n>> - amsgrad: 是否使用amsgrad技术。\n\n### LAMDA_SSL.Optimizer.SGD\n> CLASS LAMDA_SSL.Optimizer.SGD.SGD((lr=0.01, momentum=0, dampening=0, weight_decay=0, nesterov=False)\n> - Parameter:\n>> - lr: 初始学习率。\n>> - momentum: 冲量。\n>> - dampening: 冲量的阻尼。\n>> - weight_decay: L2正则对应的权重。\n>> - nesterov: 是否使用nesterov冲量。\n\n## LAMDA_SSL.Sampler\n\n### LAMDA_SSL.Sampler.BatchSampler\n> CLASS LAMDA_SSL.Sampler.BatchSampler.BatchSampler(batch_size, drop_last)\n> - Parameter:\n>> - batch_size: 批数据大小。\n>> - drop_last: 是否丢弃不足一个batch的数据。\n> - init_sampler(sampler): 通过采样器初始化批采样器。\n>> sampler: 使用的基本采样器。\n\n### LAMDA_SSL.Sampler.SequentialSampler\n> CLASS LAMDA_SSL.Sampler.SequentialSampler.SequentialSampler()\n> - init_sampler(data_source):  通过数据对采样器进行初始化。\n>> - data_source: 待采样数据。\n\n### LAMDA_SSL.Sampler.RandomSampler\n> CLASS LAMDA_SSL.Sampler.RandomSampler.RandomSampler(replacement = False, num_samples = None, generator=None)\n> - Parameter:\n>> - replacement: 是否重复采样。\n>> - num_samples: 采样总量。\n>> - generator: 同于生产采样序列的生成器。\n> - init_sampler(data_source):  通过数据对采样器进行初始化。\n>> - data_source: 待采样数据。\n\n### LAMDA_SSL.Sampler.DistributedSampler\n> CLASS LAMDA_SSL.Sampler.DistributedSampler.DistributedSampler(num_replicas=None, rank=None, shuffle=True, seed=0, drop_last=False)\n> - Parameter:\n>> - num_replicas: 参与分布式训练的进程数。\n>> - rank: 当前进程在num_replicas的排序。\n>> - shuffle: 采样是否打乱。\n>> - seed: 打乱过程中使用的随机种子。\n>> - drop_last: 对于冗余的不够一批次的数据是否丢除。\n> - init_sampler(data_source):  通过数据对采样器进行初始化。\n>> - data_source: 待采样数据。\n\n## LAMDA_SSL.Scheduler\n\n### LAMDA_SSL.Scheduler.CosineAnnealingLR\n> CLASS LAMDA_SSL.Scheduler.CosineAnnealingLR.CosineAnnealingLR(T_max, eta_min=0, last_epoch=-1, verbose=False)\n> - Parameter:\n>> - T_max: 最大迭代次数。\n>> - eta_min: 最小学习率。\n>> - last_epoch: 最后一个轮次的索引。\n>> - verbose: 是否输出冗余信息。\n\n### LAMDA_SSL.Scheduler.StepLR\n> CLASS LAMDA_SSL.Scheduler.StepLR.StepLR(step_size, gamma=0.1, last_epoch=-1, verbose=False)\n> - Parameter:\n>> - step_size: 学习率衰减期。\n>> - gamma: 学习率衰减的因子。\n>> - last_epoch: 最后一个轮次的索引。\n>> - verbose: 是否输出冗余信息。\n\n### LAMDA_SSL.Scheduler.LinearWarmup\n> CLASS LAMDA_SSL.Scheduler.LinearWarmup.LinearWarmup(num_training_steps,\n                 num_warmup_steps=0,\n                 start_factor=0,\n                 end_factor=1,\n                 last_epoch=-1，verbose=True)\n> - Parameter:\n>> - num_training_steps: 训练总迭代次数。\n>> - num_warmup_steps: 预热的迭代次数。\n>> - start_factor: 初始的学习率变动因子。\n>> - end_factor: 最终的学习率变动因子。\n>> - last_epoch: 最后一个轮次的索引。\n>> - verbose: 是否输出冗余信息。\n\n### LAMDA_SSL.Scheduler.CosineWarmup\n> CLASS LAMDA_SSL.Scheduler.CosineWarmup.CosineWarmup(num_training_steps, num_training_steps, num_warmup_steps=0, num_cycles=7./16, last_epoch=-1,verbose=True) \n> - Parameter:\n>> - num_training_steps: 训练总迭代次数。\n>> - num_warmup_steps: 预热的迭代次数。\n>> - num_cycles: 用于确定学习力变动因子的上界。\n>> - last_epoch:最后一个轮次的索引。\n>> - verbose: 是否输出冗余信息。\n\n## LAMDA_SSL.Search\n### LAMDA_SSL.Search.BayesSearchCV\n> CLASS LAMDA_SSL.Search.BayesSearchCV.BayesSearchCV(estimator,param_distributions,n_iter=10,random_state=None,warm_up=2,lam=3,y_max=1, xi=0.01, kappa=None,acquisition_func='PI',scoring=None,n_jobs=None,refit=True,cv=None,verbose=0,pre_dispatch=\"2*n_jobs\",error_score=np.nan,return_train_score=True,)\n> - Parameter:\n>> - estimator: 需要搜索参数的估计器。\n>> - param_distributions: 字典形式，key为待搜索参数名，value为取值范围或分布。\n>> - n_iter: 迭代次数。\n>> - random_state: 随机种子状态。\n>> - warm_up: 初始状态下随机采样参数的次数。\n>> - lam: 每次迭代需要采样评估的参数组数。\n>> - y_max: acquisition_func为'PI'和'EI'时有效，表示得分的最大值。\n>> - xi: acquisition_func为'PI'和'EI'时有效，用于权衡探索和利用的参数。\n>> - kappa: acquisition_func为'UCB'时有效，用于权衡均值与方差。\n>> - acquisition_func: 预估参数得分的函数，可选'PI'，'EI'和'UCB'或者可以调用的函数。\n>> - scoring: 评估参数优劣的函数。\n>> - n_jobs: 搜索时并行程序的个数。\n>> - refit: 搜索结束后是否用最优参数和所有数据重新fit估计器。\n>> - cv: k折交叉验证中k的取值或用于交叉验证的数据生成器或迭代器。\n>> - verbose: 管理输出，越大输出信息越多。\n>> - pre_dispatch: 控制在并行执行期间分派的作业数。\n>> - error_score: 如果出现错误如何对score赋值。\n>> - return_train_score: 结果中是否包含训练得分。\n\n### LAMDA_SSL.Search.EvolutionaryStrategySearchCV\n> CLASS LAMDA_SSL.Search.EvolutionaryStrategySearchCV.EvolutionaryStrategySearchCV(estimator,param_distributions,n_iter=10,random_state=None,scoring=None,n_jobs=None,refit=True,cv=None,verbose=0,pre_dispatch=\"2*n_jobs\",error_score=np.nan,return_train_score=True,)\n> - Parameter:\n>> - estimator: 需要搜索参数的估计器。\n>> - param_distributions: 字典形式，key为待搜索参数名，value为取值范围或分布。\n>> - n_iter: 迭代次数。\n>> - random_state: 随机种子状态。\n>> - warm_up: 初始状态下随机采样参数的次数。\n>> - lam: 1+\\lambda演化策略中\\lambda的取值，即每次迭代中子代的数量。\n>> - scoring: 评估参数优劣的函数。\n>> - n_jobs: 搜索时并行程序的个数。\n>> - refit: 搜索结束后是否用最优参数和所有数据重新fit估计器。\n>> - cv: k折交叉验证中k的取值或用于交叉验证的数据生成器或迭代器。\n>> - verbose: 管理输出，越大输出信息越多。\n>> - pre_dispatch: 控制在并行执行期间分派的作业数。\n>> - error_score: 如果出现错误如何对score赋值。\n>> - return_train_score: 结果中是否包含训练得分。\n\n### LAMDA_SSL.Search.BayesSearchCV\n> CLASS LAMDA_SSL.Search.BayesSearchCV.BayesSearchCV(estimator,param_distributions,meta_learner=SVR(),n_iter=10,random_state=None,warm_up=2,lam=3,scoring=None,n_jobs=None,refit=True,cv=None,verbose=0,pre_dispatch=\"2*n_jobs\",error_score=np.nan,return_train_score=True,)\n> - Parameter:\n>> - estimator: 需要搜索参数的估计器。\n>> - param_distributions: 字典形式，key为待搜索参数名，value为取值范围或分布。\n>> - meta_learner: 用于拟合参数和分数的元回归器。\n>> - n_iter: 迭代次数。\n>> - random_state: 随机种子状态。\n>> - warm_up: 初始状态下随机采样参数的次数。\n>> - lam: 每次迭代需要采样评估的参数组数。\n>> - scoring: 评估参数优劣的函数。\n>> - n_jobs: 搜索时并行程序的个数。\n>> - refit: 搜索结束后是否用最优参数和所有数据重新fit估计器。\n>> - cv: k折交叉验证中k的取值或用于交叉验证的数据生成器或迭代器。\n>> - verbose: 管理输出，越大输出信息越多。\n>> - pre_dispatch: 控制在并行执行期间分派的作业数。\n>> - error_score: 如果出现错误如何对score赋值。\n>> - return_train_score: 结果中是否包含训练得分。\n\n## LAMDA_SSL.Split\n### LAMDA_SSL.Split.DataSplit\n> Function LAMDA_SSL.Split.DataSplit.DataSplit(stratified, shuffle, random_state=None, X=None, y=None,labeled_size=None)\n> - Parameter:\n>> - stratified: 是否按类别分层。\n>> - shuffle: 是否对样本进行打乱。\n>> - random_state: 随机种子。\n>> - X: 待分割的数据样本。\n>> - y: 待分割的数据标注。\n>> - labeled_size: 有标注数据的比例或大小。\n\n### LAMDA_SSL.Split.ViewSplit\n> Function LAMDA_SSL.Split.ViewSplit.ViewSplit(X,num_splits=2,axis=1,shuffle=True)\n> - Parameter:\n>> - X: 待分割的数据样本。\n>> - num_splits: 分割后得到的视图数量。\n>> - axis: 分割特征维度的坐标。\n>> - shuffle: 是否对特征进行打乱。\n\n## LAMDA_SSL.Transform\n\n### LAMDA_SSL.Transform.Tabular\n\n#### LAMDA_SSL.Transform.Tabular.MinMaxScaler\n> CLASS LAMDA_SSL.Transform.Tabular.MinMaxScaler.MinMaxScaler(min_val=None,max_val=None)\n> - Parameter:\n>> - min_val: 最小值。\n>> - max_val: 最大值。\n\n#### LAMDA_SSL.Transform.Tabular.StandardScaler\n> CLASS LAMDA_SSL.Transform.Tabular.StandardScaler.StandardScaler(mean=None,std=None)\n> - Parameter:\n>> - mean: 均值。\n>> - std: 方差。\n\n#### LAMDA_SSL.Transform.Tabular.MaxAbsScaler\n> CLASS LAMDA_SSL.Transform.Tabular.MaxAbsScaler.MaxAbsScaler(max_abs=None)\n> - Parameter:\n>> - max_abs: 绝对值的最大值。\n\n### LAMDA_SSL.Transform.Vision\n\n#### LAMDA_SSL.Transform.Vision.Normalization\n> CLASS LAMDA_SSL.Transform.Vision.Normalization.Normalization(mean=None,std=None)\n> - Parameter:\n>> - mean: 均值。\n>> - std: 方差。\n\n#### LAMDA_SSL.Transform.Vision.Resize\n> CLASS LAMDA_SSL.Transform.Vision.Resize.Resize(size, interpolation = InterpolationMode.BILINEAR,\nmax_size = None, antialias = None)\n> - Parameter:\n>> - size: 调整后的图像大小。\n>> - interpolation: 插值方法。\n>> - max_size: 调整图像后允许的的较长边长度的最大值\n>> - antialias: 抗锯齿标志。\n\n### LAMDA_SSL.Transform.Text\n\n#### LAMDA_SSL.Transform.Text.Tokenizer\n\n> CLASS LAMDA_SSL.Transform.Text.Tokenizer.Tokenizer(tokenizer, language='en')\n> - Parameter:\n>> - tokenizer: 用于分词的函数名，如basic_english, spacy, moses, toktok, revtok, subword等。\n>> - language: 文本的语言。\n\n#### LAMDA_SSL.Transform.Text.Vocab\n> CLASS LAMDA_SSL.Transform.Text.Vocab.Vocab(word_vocab=None,vectors=None,text=None,min_freq=1,specials=[\"<unk>\",\"<pad>\"],special_first=True,default_index=None,tokenizer=None)\n> - Parameter:\n>> - word_vocab: 词到下标的映射表。\n>> - vectors: 词向量。\n>> - text: word_vocab为None时，利用text建立映射表。\n>> - min_freq: word_vocab为None时，建立映射表时可用token的最低频率。\n>> - specials: 特殊字符列表。\n>> - special_first: 是否将特殊字符放在映射表最前面。\n>> - default_index: 对于无法得到下标的单词使用的默认下标。\n>> - tokenizer: 使用的分词方法。\n\n#### LAMDA_SSL.Transform.Text.Vectors\n> CLASS LAMDA_SSL.Transform.Text.Vectors.Vectors(name, cache=None, url=None, unk_init=None,pad_init=None, max_vectors=None,lower_case_backup=True, pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - name: 词向量的名字。\n>> - cache: 缓存向量的目录。\n>> - url: 词向量下载地址。\n>> - unk_init: 默认情况下，将词汇表外的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_init: 默认情况下，将待填充的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - max_vectors: 词向量的最大数量。\n>> - lower_case_backup: 是否在查找单词时全部转化为小写。\n>> - pad_token: 默认的填充token。\n>> - unk_token: 默认的未知单词填充token。\n\n#### LAMDA_SSL.Transform.Text.CharNGram\n> CLASS LAMDA_SSL.Transform.Text.CharNGram.CharNGram(lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - lower_case_backup: 是否在查找单词时全部转化为小写。\n>> - unk_init: 默认情况下，将词汇表外的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_init: 默认情况下，将待填充的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_token: 默认的填充token。\n>> - unk_token: 默认的未知单词填充token。\n\n#### LAMDA_SSL.Transform.Text.FastText\n> CLASS LAMDA_SSL.Transform.Text.FastText.FastText(language=\"en\",lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - language: 文本语言类型。\n>> - lower_case_backup: 是否在查找单词时全部转化为小写。\n>> - unk_init: 默认情况下，将词汇表外的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_init: 默认情况下，将待填充的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_token: 默认的填充token。\n>> - unk_token: 默认的未知单词填充token。\n\n#### LAMDA_SSL.Transform.Text.GloVe\n> CLASS LAMDA_SSL.Transform.Text.GloVe.GloVe(name=\"840B\", dim=300,lower_case_backup=True,unk_init=None,pad_init=None,pad_token='<pad>',unk_token='<unk>')\n> - Parameter:\n>> - name: 词向量的名字。\n>> - dim: 词向量的维度。\n>> - lower_case_backup: 是否在查找单词时全部转化为小写。\n>> - unk_init: 默认情况下，将词汇表外的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_init: 默认情况下，将待填充的词向量初始化为零向量； 可以是任何接受张量并返回相同大小的张量的函数。\n>> - pad_token: 默认的填充token。\n>> - unk_token: 默认的未知单词填充token。\n\n#### LAMDA_SSL.Transform.Text.Truncate\n> CLASS LAMDA_SSL.Transform.Text.Truncate.Truncate(length=100,pos=0)\n> - Parameter:\n>> - length: 裁剪后的文本长度。\n>> - pos: 开始裁剪的位置。\n\n#### LAMDA_SSL.Transform.Text.PadSequence\n> CLASS LAMDA_SSL.Transform.Text.PadSequence.PadSequence(length,pad_val=None)\n> - Parameter:\n>> - length: 文本填充后的长度。\n>> - pad_val: 填充值。\n\n#### LAMDA_SSL.Transform.Text.AdjustLength\n> CLASS LAMDA_SSL.Transform.Text.AdjustLength.AdjustLength(length, pad_val=None, pos=0)\n> - Parameter:\n>> - length: 调整后的句长。\n>> - pad_val: 对于不足长度的文本进行填充。\n>> - pos；如果句长过长，需要切割，则该参数指明开始切割的位置。\n\n### LAMDA_SSL.Transform.Graph\n\n#### LAMDA_SSL.Transform.Graph.NormalizeFeatures\n> CLASS LAMDA_SSL.Transform.Graph.NormalizeFeatures.NormalizeFeatures(attrs=[\"x\"])\n> - Parameter:\n>> - attrs: 需要正则化的属性。\n\n#### LAMDA_SSL.Transform.Graph.GDC\n> CLASS LAMDA_SSL.Transform.Graph.GDC.GDC(self_loop_weight=1, normalization_in='sym',\n                 normalization_out='col',\n                 diffusion_kwargs=dict(method='ppr', alpha=0.15),\n                 sparsification_kwargs=dict(method='threshold',avg_degree=64),\n                 exact=True)\n> - Parameter:\n>> - self_loop_weight: 添加自环的权重。\n>> - normalization_in: 原始（输入）图上转换矩阵的归一化方法，可选\"sym\"，\"col\"和\"row\"。\n>> - normalization_out: 转换后的 GDC（输出）图上转换矩阵的归一化方法，可选\"sym\"，\"col\"和\"row\"。\n>> - diffusion_kwargs: 包含扩散参数的字典。\n>> - sparsification_kwargs: 包含稀疏化参数的字典。\n>> - exact: 是否精确计算扩散矩阵。\n\n#### LAMDA_SSL.Transform.Graph.GCNNorm\n> CLASS LAMDA_SSL.Transform.Graph.GCNNorm.GCNNorm(add_self_loops=True)\n> - Parameter:\n>> - add_self_loops: 是否增加自环。\n\n#### LAMDA_SSL.Transform.Graph.SVDFeatureReduction\n> CLASS LAMDA_SSL.Transform.Graph.SVDFeatureReduction.SVDFeatureReduction(out_channels)\n> - Parameter:\n>> - out_channels: 降维后的维度。\n\n### LAMDA_SSL.Transform.ToImage\n> CLASS LAMDA_SSL.Transform.ToImage.ToImage(channels=3,channels_first=True)\n> - Parameter:\n>> - out_channels: 图片的通道数。\n>> - channels_first: 对于输入数据的维度，通道数是否在图片大小之前。\n\n### LAMDA_SSL.Transform.ToNumpy\n> CLASS LAMDA_SSL.Transform.ToNumpy.ToNumpy()\n\n### LAMDA_SSL.Transform.ToTensor\n> CLASS LAMDA_SSL.Transform.ToTensor.ToTensor(dtype=None,image=False)\n> - Parameter:\n>> - dtype: 转换后Tensor中数据的类型。\n>> - image: 输入是否是图片。\n\n# 常见问题\n\n1. LAMDA-SSL的接口和sklearn半监督学习模块的接口有什么不同？\n\nsklearn的接口的fit()方法一般有X和y两项，无标注的X对应的标注y用-1表示。但是在很多二分类任务中，-1表示负类，容易冲突，因此LAMDA-SSL的fit()方法有X,y和unlabeled_X三项输入。\n\n2. DeepModelMixin模块如何理解？\n\n这一模块主要是使深度学习与经典机器学习拥有相同的接口，并且为了便于用户更换深度学习种对应的组件，DeepModelMixin对pytorch进行了解耦。\n\n# 参考文献\n\n\n[1]\tVAN ENGELEN J E, HOOS H H. A survey on semi-supervised learning[J]. Machine Learning, 2020, 109(2): 373-440.\n\n[2]\tOUALI Y, HUDELOT C, TAMI M. An Overview of Deep Semi-Supervised Learning[J/OL]. arXiv:2006.05278 [cs, stat], 2020[2022-03-01]. http://arxiv.org/abs/2006.05278.\n\n[3]\tYANG X, SONG Z, KING I, et al. A Survey on Deep Semi-supervised Learning[J/OL]. arXiv:2103.00550 [cs], 2021[2022-03-01]. http://arxiv.org/abs/2103.00550.\n\n[4]\tSHAHSHAHANI B M, LANDGREBE D A. The Effect of Unlabeled Samples in Reducing the Small Sample Size Problem and Mitigating the Hughes Phenomenon[J]. IEEE Transactions on Geoscience and remote sensing, 1994, 32(5): 1087-1095.\n\n[5]\tJOACHIMS T. Transductive Inference for Text Classi cation using Support Vector Machines[C].  International Conference on Machine Learning, 1999, 99.\n\n[6]\tBELKIN M, NIYOGI P, SINDHWANI V. Manifold Regularization: A Geometric Framework for Learning from Labeled and Unlabeled Examples[J]. Journal of machine learning research, 2006, 7(11).\n\n[7]\tZHU X, GHAHRAMANI Z. Learning from Labeled and Unlabeled Data with Label Propagation[R], 2002.\n\n[8]\tZHOU D, BOUSQUET O, LAL T, et al. Learning with Local and Global Consistency[C]. Advances in Neural Information Processing Systems, 2003, Vol. 16.\n\n[9]\tBLUM A, MITCHELL T. Combining labeled and unlabeled data with co-training[C]. Proceedings of the eleventh annual conference on Computational learning theory. Conference on Learning Theory, 1998: 92-100.\n\n[10]\tZHI-HUA ZHOU, MING LI. Tri-training: exploiting unlabeled data using three classifiers[J]. IEEE Transactions on Knowledge and Data Engineering, 2005, 17(11): 1529-1541. \n\n[11]\tBENNETT K P, DEMIRIZ A, MACLIN R. Exploiting Unlabeled Data in Ensemble Methods[C]. Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining, 2002.\n\n[12]\tMALLAPRAGADA P K, RONG JIN, JAIN A K, et al. SemiBoost: Boosting for Semi-Supervised Learning[J]. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2009, 31(11): 2000-2014.\n\n[13]\tZHOU Z H, LI M. Semi-Supervised Regression with Co-Training[C]. International Joint Conference on Artificial Intelligence, 2005, 5.\n\n[14]\tWAGSTAFF K, CARDIE C, ROGERS S, et al. Constrained K-means Clustering with Background Knowledge[C]. International Conference on Machine Learning, 2001, 1.\n\n[15]\tBASU S, BANERJEE A, MOONEY R. Semi-supervised Clustering by Seeding[C]//In Proceedings of 19th International Conference on Machine Learning. 2002.\n\n[16]\tRASMUS A, BERGLUND M, HONKALA M, et al. Semi-supervised Learning with Ladder Networks[C]. Advances in Neural Information Processing Systems, 2015, 28.\n\n[17]\tXIE Q, DAI Z, HOVY E, et al. Unsupervised Data Augmentation for Consistency Training[C]. Advances in Neural Information Processing Systems, 2020, 33: 6256-6268.\n\n[18]\tLAINE S, AILA T. Temporal Ensembling for Semi-Supervised Learning[C]. International Conference on Learning Representations, 2017, 4(5): 6.\n\n[19]\tTARVAINEN A, VALPOLA H. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results[C]. Advances in Neural Information Processing Systems, 2017, 30.\n\n[20]\tMIYATO T, MAEDA S ichi, KOYAMA M, et al. Virtual Adversarial Training: A Regularization Method for Supervised and Semi-Supervised Learning[J]. IEEE transactions on pattern analysis and machine intelligence, 2018, 41(8): 1979-1993.\n\n[21]\tLEE D H. Pseudo-Label : The Simple and Efficient Semi-Supervised Learning Method for Deep Neural Networks[C]. ICML 2013 Workshop : Challenges in Representation Learning (WREPL), 2013, 3(2): 869.\n\n[22]\tZHAI X, OLIVER A, KOLESNIKOV A, et al. S4L: Self-Supervised Semi-Supervised Learning[C]. Proceedings of the IEEE/CVF International Conference on Computer Vision. 2019: 1476-1485.\n\n[23]\tVERMA V, KAWAGUCHI K, LAMB A, et al. Interpolation Consistency Training for Semi-Supervised Learning[C]. International Joint Conference on Artificial Intelligence, 2019: 3635-3641\n\n[24]\tBERTHELOT D, CARLINI N, GOODFELLOW I, et al. MixMatch: A Holistic Approach to Semi-Supervised Learning[C]. Advances in Neural Information Processing Systems, 2019, 32.\n\n[25]\tBERTHELOT D, CARLINI N, CUBUK E D, et al. ReMixMatch: Semi-Supervised Learning with Distribution Alignment and Augmentation Anchoring[J/OL]. arXiv:1911.09785 [cs, stat], 2020[2022-03-02]. http://arxiv.org/abs/1911.09785.\n\n[26]\tSOHN K, BERTHELOT D, LI C L, et al. FixMatch: Simplifying Semi-Supervised Learning with Consistency and Confidence[J]. 21.\n\n[27]\tZHANG B, WANG Y, HOU W, et al. Flexmatch: Boosting semi-supervised learning with curriculum pseudo labeling[J]. Advances in Neural Information Processing Systems, 2021, 34.\n\n[28]\tSALIMANS T, GOODFELLOW I, ZAREMBA W, et al. Improved Techniques for Training GANs[C]. Advances in Neural Information Processing Systems, 2016, 29.\n\n[29]\tKINGMA D P, REZENDE D J, MOHAMED S, et al. Semi-Supervised Learning with Deep Generative Models[C]. Advances in neural information processing systems, 2014, 27.\n\n[30]\tWANG D, CUI P, ZHU W. Structural Deep Network Embedding[C]. Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 2016: 1225-1234.\n\n[31]\tKIPF T N, WELLING M. Semi-Supervised Classification with Graph Convolutional Networks[C]. International Conference on Learning Representations, 2017.\n\n[32]    Velickovic, Petar, et al. Graph attention networks[C]. International Conference on Learning Representations, 2018.\n\n[33]\tPEDREGOSA F, VAROQUAUX G, GRAMFORT A, et al. Scikit-learn: Machine Learning in Python[J]. The Journal of Machine Learning Research, 2001, 12: 2825-2830.\n\n[34]\tZHANG H, CISSE M, DAUPHIN Y N, et al. mixup: Beyond Empirical Risk Minimization[C]. International Conference on Learning Representations, 2018. \n\n[35]\tSCARSELLI F, GORI M, TSOI A C, et al. The graph neural network model[J]. IEEE transactions on neural networks, 2008, 20(1): 61-80.\n\n[36]\tGASTEIGER J, WEISSENBERGER S, GÜNNEMANN S. Diffusion Improves Graph Learning[J/OL]. arXiv:1911.05485 [cs, stat], 2022. http://arxiv.org/abs/1911.05485.\n\n[37]\tDAVIES D, BOULDIN D. A Cluster Separation Measure[J]. IEEE Transactions on Pattern Analysis and Machine Intelligence, 1979, 2: 224-227.\n\n[38]\tFOWLKES E B, MALLOWS C L. A Method for Comparing Two Hierarchical Clusterings[J]. Journal of the American Statistical Association, 1983, 78(383): 553-569.\n\n[39]\tRAND W M. Objective Criteria for the Evaluation of Clustering Methods[J]. Journal of the American Statistical Association, 2012, 66(336): 846-850.\n\n[40]\tCUBUK E D, ZOPH B, SHLENS J, et al. Randaugment: Practical automated data augmentation with a reduced search space[C]. IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), 2020: 3008-3017.\n"
  },
  {
    "path": "docs/zh-cn/_coverpage.md",
    "content": "<!-- _coverpage.md -->\n<img width=\"200px\" style=\"border-radius: 50%\" src=\"./Logo.png\" > \n<!-- ![logo](Logo.png) -->\n\n# Semi-sklearn <small>1.0</small>\n\n> 一款易用有效的半监督学习工具包\n\n- \n- \n- \n\n[GitHub](https://github.com/YGZWQZD/Semi-sklearn/)\n[Get Started](?id=Introduction)\n"
  },
  {
    "path": "docs/zh-cn/_sidebar.md",
    "content": "- [介绍](/zh-cn/README.md?id=介绍)\n    - [背景](/zh-cn/README.md?id=背景)\n    - [编写目的](/zh-cn/README.md?id=编写目的)\n    - [设计模式](/zh-cn/README.md?id=设计模式)\n        - [数据模块](/zh-cn/README.md?id=数据模块)\n        - [模型模块](/zh-cn/README.md?id=模型模块)\n    - [应用场景](/zh-cn/README.md?id=应用场景)\n        - [数据场景](/zh-cn/README.md?id=数据场景)\n        - [任务场景](/zh-cn/README.md?id=任务场景)\n    - [算法实现](/zh-cn/README.md?id=算法实现)\n        - [基于统计机器学习模型的半监督学习算法](/zh-cn/README.md?id=基于统计机器学习模型的半监督学习算法)\n        - [基于深度学习模型的半监督学习算法](/zh-cn/README.md?id=基于深度学习模型的半监督学习算法)\n\n- [使用教程](/zh-cn/README.md?id=使用教程)\n    - [数据导入](/zh-cn/README.md?id=数据导入)\n    - [数据变换](/zh-cn/README.md?id=数据变换)\n    - [Pipeline机制](/zh-cn/README.md?id=Pipeline机制)\n    - [训练一个归纳式统计半监督分类模型](/zh-cn/README.md?id=训练一个归纳式统计半监督分类模型)\n    - [训练一个直推式统计半监督分类模型](/zh-cn/README.md?id=训练一个直推式统计半监督分类模型)\n    - [训练一个多视图统计半监督分类模型](/zh-cn/README.md?id=训练一个多视图统计半监督分类模型)\n    - [训练一个统计半监督回归模型](/zh-cn/README.md?id=训练一个统计半监督回归模型)\n    - [训练一个统计半监督聚类模型](/zh-cn/README.md?id=训练一个统计半监督聚类模型)\n    - [训练一个默认配置的深度半监督模型](/zh-cn/README.md?id=训练一个默认配置的深度半监督模型)\n    - [训练一个自定义配置的深度半监督模型](/zh-cn/README.md?id=训练一个自定义配置的深度半监督模型)\n    - [训练一个深度半监督文本分类模型](/zh-cn/README.md?id=训练一个深度半监督文本分类模型)\n    - [训练一个深度半监督回归模型](/zh-cn/README.md?id=训练一个深度半监督回归模型)\n    - [训练一个深度生成式模型](/zh-cn/README.md?id=训练一个深度生成式模型)\n    - [训练一个深度图模型](/zh-cn/README.md?id=训练一个深度图模型)\n    - [训练一个分布式深度半监督模型](/zh-cn/README.md?id=训练一个分布式深度半监督模型)\n    - [模型评估](/zh-cn/README.md?id=模型评估)\n    - [模型验证](/zh-cn/README.md?id=模型验证)\n    - [参数搜索](/zh-cn/README.md?id=参数搜索)\n    - [保存和加载模型](/zh-cn/README.md?id=保存和加载模型)\n    - [自定义数据](/zh-cn/README.md?id=自定义数据)\n    - [自定义数据变换](/zh-cn/README.md?id=自定义数据变换)\n    - [自定义采样器](/zh-cn/README.md?id=自定义采样器)\n    - [自定义优化器](/zh-cn/README.md?id=自定义优化器)\n    - [自定义学习率调度器](/zh-cn/README.md?id=自定义学习率调度器)\n    - [自定义损失函数](/zh-cn/README.md?id=自定义损失函数)\n    - [自定义评估指标](/zh-cn/README.md?id=自定义评估指标)\n    - [自定义统计半监督学习算法](/zh-cn/README.md?id=自定义统计半监督学习算法)\n    - [自定义深度半监督学习算法](/zh-cn/README.md?id=自定义深度半监督学习算法)\n\n- [用户指南](/zh-cn/README.md?id=用户指南)\n    - [基于经典机器学习的半监督学习算法](/zh-cn/README.md?id=基于经典机器学习的半监督学习算法)\n        - [生成式方法](/zh-cn/README.md?id=生成式方法)\n            - [SSGMM](/zh-cn/README.md?id=SSGMM)\n        - [半监督支持向量机方法](/zh-cn/README.md?id=半监督支持向量机方法)\n            - [TSVM](/zh-cn/README.md?id=TSVM)\n            - [LapSVM](/zh-cn/README.md?id=LapSVM)\n        - [基于图的方法](/zh-cn/README.md?id=基于图的方法)\n            - [Label Propagation](/zh-cn/README.md?id=Label-Propagation)\n            - [Label Spreading](/zh-cn/README.md?id=Label-Spreading)\n        - [基于分歧的方法](/zh-cn/README.md?id=基于分歧的方法)\n            - [Co-Training](/zh-cn/README.md?id=Co-Training)\n            - [Tri-Training](/zh-cn/README.md?id=Tri-Training)\n        - [集成方法](/zh-cn/README.md?id=集成方法)\n            - [Assemble](/zh-cn/README.md?id=Assemble)\n            - [SemiBoost](/zh-cn/README.md?id=SemiBoost)\n        - [半监督回归方法](/zh-cn/README.md?id=半监督回归方法)\n            - [CoReg](/zh-cn/README.md?id=CoReg)\n        - [半监督聚类方法](/zh-cn/README.md?id=半监督聚类方法)\n            - [Constrained k-means](/zh-cn/README.md?id=Constrained-k-means)\n            - [Constrained Seed k-means](/zh-cn/README.md?id=Constrained-Seed-k-means)\n    - [基于深度习的半监督学习算法](/zh-cn/README.md?id=基于深度学习的半监督学习算法)\n        - [一致性正则方法](/zh-cn/README.md?id=一致性正则方法)\n            - [Ladder Network](/zh-cn/README.md?id=Ladder-Network)\n            - [UDA](/zh-cn/README.md?id=UDA)\n            - [Pi-Model](/zh-cn/README.md?id=Pi-Model)\n            - [Temporal-Ensembling](/zh-cn/README.md?id=Temporal-Ensembling)\n            - [MeanTeacher](/zh-cn/README.md?id=Mean-Teacher)\n            - [VAT](/zh-cn/README.md?id=VAT)\n        - [伪标注方法](/zh-cn/README.md?id=伪标注方法)\n            - [Pseudo Label](/zh-cn/README.md?id=Pseudo-Label)\n            - [S4L](/zh-cn/README.md?id=S4L)\n        - [混合方法](/zh-cn/README.md?id=混合方法)\n            - [ICT](/zh-cn/README.md?id=ICT)\n            - [MixMatch](/zh-cn/README.md?id=MixMatch)\n            - [ReMixMatch](/zh-cn/README.md?id=ReMixMatch)\n            - [FixMatch](/zh-cn/README.md?id=FixMatch)\n            - [FlexMatch](/zh-cn/README.md?id=FlexMatch)\n        - [深度生成式方法](/zh-cn/README.md?id=深度生成式方法)\n            - [ImprovedGAN](/zh-cn/README.md?id=ImprovedGAN)\n            - [SSVAE](/zh-cn/README.md?id=SSVAE)\n        - [深度图方法](/zh-cn/README.md?id=深度图方法)\n            - [SDNE](/zh-cn/README.md?id=SDNE)\n            - [GCN](/zh-cn/README.md?id=GCN)\n            - [GAT](/zh-cn/README.md?id=GAT)\n\n- [API](/zh-cn/README.md?id=API)\n    - [LADMA_SSL.Algorithm](/zh-cn/README.md?id=lamda_sslalgorithm)\n    - [LADMA_SSL.Augmentation](/zh-cn/README.md?id=lamda_sslaugmentation)\n    - [LADMA_SSL.Base](/zh-cn/README.md?id=lamda_sslbase)\n    - [LADMA_SSL.Dataloader](/zh-cn/README.md?id=lamda_ssldataloader)\n    - [LADMA_SSL.Dataset](/zh-cn/README.md?id=lamda_ssldataset)\n    - [LADMA_SSL.Distributed](/zh-cn/README.md?id=lamda_ssldistributed)\n    - [LADMA_SSL.Evaluation](/zh-cn/README.md?id=lamda_sslevaluation)\n    - [LADMA_SSL.Loss](/zh-cn/README.md?id=lamda_sslloss)\n    - [LADMA_SSL.Network](/zh-cn/README.md?id=lamda_sslnetwork)\n    - [LADMA_SSL.Optimizer](/zh-cn/README.md?id=lamda_ssloptimizer)\n    - [LADMA_SSL.Sampler](/zh-cn/README.md?id=lamda_sslsampler)\n    - [LADMA_SSL.Scheduler](/zh-cn/README.md?id=lamda_sslscheduler)\n    - [LADMA_SSL.Split](/zh-cn/README.md?id=lamda_sslsplit)\n    - [LADMA_SSL.Transform](/zh-cn/README.md?id=lamda_ssltransform)\n\n- [常见问题](/zh-cn/README.md?id=常见问题)\n\n- [参考文献](/zh-cn/README.md?id=参考文献)"
  },
  {
    "path": "environment.yaml",
    "content": "name: LAMDA-SSL\nchannels:\n  - pyg\n  - conda-forge\n  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch\n  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main\n  - default\n  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/win-64/\n  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/\n  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/\n\ndependencies:\n  - matplotlib=3.5.0\n  - numpy=1.19.2\n  - pandas=1.3.4\n  - pillow=8.4.0\n  - pip=21.2.4\n  - pyg=2.0.3\n  - python=3.7.9\n  - pytorch=1.10.1\n  - scikit-learn=1.0.2\n  - scipy=1.5.2\n  - torchtext=0.11.1\n  - torchvision=0.11.2\n"
  },
  {
    "path": "setup.py",
    "content": "# -*- coding: utf-8 -*-\n\n\"\"\"\nAuthor     : Lin-Han Jia, Lan-Zhe Guo and Zhi Zhou\nDescription: LAMDA-SSL is an useful toolkit for semi-supervised learning.\n\"\"\"\n\nimport setuptools\n\nwith open(\"README.md\", \"r\", encoding='utf-8') as fh:\n    long_description = fh.read()\n\nsetuptools.setup(\n    name='LAMDA-SSL',\n    version=\"1.0.2\",\n    author=\"Lin-Han Jia, Lan-Zhe Guo, Zhi Zhou, Yu-Feng Li\",\n    license='MIT',\n    author_email=\"1129198222@qq.com\",\n    description=\"LAMDA-SSL is an useful toolkit for semi-supervised learning.\",\n    long_description=long_description,\n    long_description_content_type=\"text/markdown\",\n    url=\"https://github.com/YGZWQZD/LAMDA-SSL\",\n    packages=setuptools.find_packages(exclude=[\"Test\",\"Unused\"]),\n    classifiers=[\n        \"Programming Language :: Python :: 3\",\n        \"License :: OSI Approved :: MIT License\",\n        \"Operating System :: OS Independent\",\n    ],\n    keywords=['Semi-Supervised Learning', 'Machine Learning', 'Deep Learning', 'Toolkit'],\n    install_requires=['scikit-learn','torchtext',\n                      'torchvision','torch-geometric','Pillow',\n                      'numpy','scipy','pandas','matplotlib'],\n    python_requires='>=3.7',\n)"
  }
]