Logo

Getting Started

  • Main Concepts
    • Self-Supervised Learning
  • Installation
    • Supported Python versions
    • Installing LightlySSL
    • Dependencies
    • Next Steps
  • Command-line tool
    • Check the installation of LightlySSL
    • Crop Images using Labels or Predictions
    • Training and Embedding in a Go – Magic
    • Train a model using the CLI
    • Create embeddings using the CLI
    • Download data using the CLI
    • Breakdown of lightly-magic
  • Self-supervised learning
    • How LightlySSL Works
      • Data and Transformations
      • Model, Loss and Training
      • Embeddings
    • What’s Next?

Advanced

  • Advanced Concepts in Self-Supervised Learning
    • Augmentations
      • Transforms
      • Custom Transforms
      • Previewing Augmentations
    • Models
    • Losses
      • Memory Bank
    • Obtaining Good Embeddings
      • Monitoring Embedding Quality
  • Distributed Training
    • Distributed Training Benchmarks
      • Observations
  • Benchmarks
    • ImageNet1k
    • ImageNet100
    • Imagenette
    • CIFAR-10
    • Next Steps

Tutorials

  • Tutorial 1: Structure Your Input
    • LightlyDataset
      • Supported File Types
      • Unlabeled Image Datasets
      • Labeled Image Datasets
      • Video Datasets
    • PyTorch Datasets
    • Hugging Face Datasets
    • Image Augmentations
    • Conclusion
  • Tutorial 2: Train MoCo on CIFAR-10
    • Imports
    • Configuration
    • Setup data augmentations and loaders
    • Create the MoCo Lightning Module
    • Create the Classifier Lightning Module
    • Train the MoCo model
    • Next Steps
  • Tutorial 3: Train SimCLR on Clothing
    • Imports
    • Configuration
    • Setup data augmentations and loaders
    • Create the SimCLR Model
    • Visualize Nearest Neighbors
    • Color Invariance
    • Next Steps
  • Tutorial 4: Train SimSiam on Satellite Images
    • Imports
    • Configuration
    • Setup data augmentations and loaders
    • Create the SimSiam model
    • Train SimSiam
    • Scatter Plot and Nearest Neighbors
    • Next Steps
  • Tutorial 5: Custom Augmentations
    • Imports
    • Configuration
    • Setup custom data augmentations
    • Setup dataset and dataloader
    • Create the MoCo model
    • Train MoCo with custom augmentations
    • Evaluate the results
  • Tutorial 6: Pre-train a Detectron2 Backbone with Lightly
    • Introduction
    • Prerequisites:
    • Imports
    • Configuration
    • Initialize the Detectron2 Model
    • Setup data augmentations and loaders
    • Self-supervised pre-training
    • Storing the checkpoint
    • Finetuning with Detectron2
    • Next Steps
  • Tutorial 7: Finetuning Lightly Checkpoints
    • Imports
    • Downloading Model Checkpoint
    • Tensorboard Logger
    • Configuration
    • Setup data augmentations and loaders
    • Load Model Checkpoint
    • Create a FineTuning Lightning Module
    • Training
    • Next Steps
  • Tutorial 8: Using timm Models as Backbones
    • Imports
    • Using a timm Model as a Backbone
    • Next Steps

Examples

  • Models
    • AIM
    • Barlow Twins
    • BYOL
    • DCL & DCLW
    • DenseCL
    • DINO
    • FastSiam
    • MAE
    • MMCR
    • MSN
    • MoCo
    • NNCLR
    • PMSN
    • SimCLR
    • SimMIM
    • SimSiam
    • SMoG
    • SwaV
    • SwaV Queue
    • TiCo
    • VICReg
    • VICRegL

Python API

  • lightly
  • lightly.api
    • ApiWorkflowClient
      • ApiWorkflowClient.compute_worker_run_info_generator()
      • ApiWorkflowClient.create_dataset()
      • ApiWorkflowClient.create_new_dataset_with_unique_name()
      • ApiWorkflowClient.create_tag_from_filenames()
      • ApiWorkflowClient.dataset_exists()
      • ApiWorkflowClient.dataset_id
      • ApiWorkflowClient.dataset_name_exists()
      • ApiWorkflowClient.dataset_type
      • ApiWorkflowClient.delete_compute_worker()
      • ApiWorkflowClient.delete_dataset_by_id()
      • ApiWorkflowClient.delete_tag_by_id()
      • ApiWorkflowClient.delete_tag_by_name()
      • ApiWorkflowClient.download_compute_worker_run_artifacts()
      • ApiWorkflowClient.download_compute_worker_run_checkpoint()
      • ApiWorkflowClient.download_compute_worker_run_corruptness_check_information()
      • ApiWorkflowClient.download_compute_worker_run_log()
      • ApiWorkflowClient.download_compute_worker_run_memory_log()
      • ApiWorkflowClient.download_compute_worker_run_report_json()
      • ApiWorkflowClient.download_compute_worker_run_report_pdf()
      • ApiWorkflowClient.download_compute_worker_run_report_v2_json()
      • ApiWorkflowClient.download_compute_worker_run_sequence_information()
      • ApiWorkflowClient.download_dataset()
      • ApiWorkflowClient.download_embeddings_csv()
      • ApiWorkflowClient.download_embeddings_csv_by_id()
      • ApiWorkflowClient.download_new_raw_samples()
      • ApiWorkflowClient.export_filenames_and_read_urls_by_tag_id()
      • ApiWorkflowClient.export_filenames_and_read_urls_by_tag_name()
      • ApiWorkflowClient.export_filenames_by_tag_id()
      • ApiWorkflowClient.export_filenames_by_tag_name()
      • ApiWorkflowClient.export_label_box_data_rows_by_tag_id()
      • ApiWorkflowClient.export_label_box_data_rows_by_tag_name()
      • ApiWorkflowClient.export_label_box_v4_data_rows_by_tag_id()
      • ApiWorkflowClient.export_label_box_v4_data_rows_by_tag_name()
      • ApiWorkflowClient.export_label_studio_tasks_by_tag_id()
      • ApiWorkflowClient.export_label_studio_tasks_by_tag_name()
      • ApiWorkflowClient.get_all_datasets()
      • ApiWorkflowClient.get_all_embedding_data()
      • ApiWorkflowClient.get_all_tags()
      • ApiWorkflowClient.get_compute_worker_ids()
      • ApiWorkflowClient.get_compute_worker_run()
      • ApiWorkflowClient.get_compute_worker_run_checkpoint_url()
      • ApiWorkflowClient.get_compute_worker_run_from_scheduled_run()
      • ApiWorkflowClient.get_compute_worker_run_info()
      • ApiWorkflowClient.get_compute_worker_run_tags()
      • ApiWorkflowClient.get_compute_worker_runs()
      • ApiWorkflowClient.get_compute_worker_runs_iter()
      • ApiWorkflowClient.get_compute_workers()
      • ApiWorkflowClient.get_dataset_by_id()
      • ApiWorkflowClient.get_datasets()
      • ApiWorkflowClient.get_datasets_by_name()
      • ApiWorkflowClient.get_datasets_iter()
      • ApiWorkflowClient.get_datasource()
      • ApiWorkflowClient.get_embedding_by_name()
      • ApiWorkflowClient.get_embedding_data_by_name()
      • ApiWorkflowClient.get_scheduled_compute_worker_runs()
      • ApiWorkflowClient.get_shared_users()
      • ApiWorkflowClient.get_tag_by_id()
      • ApiWorkflowClient.get_tag_by_name()
      • ApiWorkflowClient.list_datasource_permissions()
      • ApiWorkflowClient.register_compute_worker()
      • ApiWorkflowClient.schedule_compute_worker_run()
      • ApiWorkflowClient.set_azure_config()
      • ApiWorkflowClient.set_dataset_id_by_name()
      • ApiWorkflowClient.set_gcs_config()
      • ApiWorkflowClient.set_local_config()
      • ApiWorkflowClient.set_obs_config()
      • ApiWorkflowClient.set_s3_config()
      • ApiWorkflowClient.set_s3_delegated_access_config()
      • ApiWorkflowClient.share_dataset_only_with()
      • ApiWorkflowClient.update_processed_until_timestamp()
      • ApiWorkflowClient.verify_custom_metadata_format()
    • ComputeWorkerRunInfo
      • ComputeWorkerRunInfo.state
      • ComputeWorkerRunInfo.message
      • ComputeWorkerRunInfo.ended_successfully()
      • ComputeWorkerRunInfo.in_end_state()
    • InvalidConfigurationError
  • lightly.cli
    • .lightly_cli
      • lightly_cli()
    • .train_cli
      • train_cli()
    • .embed_cli
      • embed_cli()
    • .download_cli
      • download_cli()
    • .version_cli
    • .crop_cli
      • crop_cli()
    • .config.config.yaml
      • Overwrites
      • Additional Arguments
      • Default Settings
  • .core
    • embed_images()
    • train_embedding_model()
    • train_model_and_embed_images()
  • lightly.data
    • .dataset
      • LightlyDataset
        • LightlyDataset.dump()
        • LightlyDataset.from_torch_dataset()
        • LightlyDataset.get_filenames()
        • LightlyDataset.get_filepath_from_filename()
        • LightlyDataset.transform
    • .multi_view_collate
      • MultiViewCollate
        • MultiViewCollate.__call__()
    • .collate:
      • BaseCollateFunction
        • BaseCollateFunction.transform
        • BaseCollateFunction.forward()
      • DINOCollateFunction
        • DINOCollateFunction.global_crop_size
        • DINOCollateFunction.global_crop_scale
        • DINOCollateFunction.local_crop_size
        • DINOCollateFunction.local_crop_scale
        • DINOCollateFunction.n_local_views
        • DINOCollateFunction.hf_prob
        • DINOCollateFunction.vf_prob
        • DINOCollateFunction.rr_prob
        • DINOCollateFunction.rr_degrees
        • DINOCollateFunction.cj_prob
        • DINOCollateFunction.cj_bright
        • DINOCollateFunction.cj_contrast
        • DINOCollateFunction.cj_sat
        • DINOCollateFunction.cj_hue
        • DINOCollateFunction.random_gray_scale
        • DINOCollateFunction.gaussian_blur
        • DINOCollateFunction.kernel_size
        • DINOCollateFunction.kernel_scale
        • DINOCollateFunction.sigmas
        • DINOCollateFunction.solarization
        • DINOCollateFunction.normalize
      • IJEPAMaskCollator
      • ImageCollateFunction
        • ImageCollateFunction.input_size
        • ImageCollateFunction.cj_prob
        • ImageCollateFunction.cj_bright
        • ImageCollateFunction.cj_contrast
        • ImageCollateFunction.cj_sat
        • ImageCollateFunction.cj_hue
        • ImageCollateFunction.min_scale
        • ImageCollateFunction.random_gray_scale
        • ImageCollateFunction.gaussian_blur
        • ImageCollateFunction.kernel_size
        • ImageCollateFunction.sigmas
        • ImageCollateFunction.vf_prob
        • ImageCollateFunction.hf_prob
        • ImageCollateFunction.rr_prob
        • ImageCollateFunction.rr_degrees
        • ImageCollateFunction.normalize
      • MAECollateFunction
        • MAECollateFunction.input_size
        • MAECollateFunction.min_scale
        • MAECollateFunction.normalize
        • MAECollateFunction.forward()
      • MSNCollateFunction
        • MSNCollateFunction.random_size
        • MSNCollateFunction.focal_size
        • MSNCollateFunction.random_views
        • MSNCollateFunction.focal_views
        • MSNCollateFunction.random_crop_scale
        • MSNCollateFunction.focal_crop_scale
        • MSNCollateFunction.cj_prob
        • MSNCollateFunction.cj_strength
        • MSNCollateFunction.gaussian_blur
        • MSNCollateFunction.kernel_size
        • MSNCollateFunction.sigmas
        • MSNCollateFunction.random_gray_scale
        • MSNCollateFunction.hf_prob
        • MSNCollateFunction.vf_prob
        • MSNCollateFunction.normalize
      • MoCoCollateFunction
        • MoCoCollateFunction.input_size
        • MoCoCollateFunction.cj_prob
        • MoCoCollateFunction.cj_strength
        • MoCoCollateFunction.min_scale
        • MoCoCollateFunction.random_gray_scale
        • MoCoCollateFunction.gaussian_blur
        • MoCoCollateFunction.kernel_size
        • MoCoCollateFunction.sigmas
        • MoCoCollateFunction.vf_prob
        • MoCoCollateFunction.hf_prob
        • MoCoCollateFunction.rr_prob
        • MoCoCollateFunction.rr_degrees
        • MoCoCollateFunction.normalize
      • MultiCropCollateFunction
        • MultiCropCollateFunction.crop_sizes
        • MultiCropCollateFunction.crop_counts
        • MultiCropCollateFunction.crop_min_scales
        • MultiCropCollateFunction.crop_max_scales
        • MultiCropCollateFunction.transforms
      • MultiViewCollateFunction
        • MultiViewCollateFunction.transforms
        • MultiViewCollateFunction.forward()
      • PIRLCollateFunction
        • PIRLCollateFunction.input_size
        • PIRLCollateFunction.cj_prob
        • PIRLCollateFunction.cj_bright
        • PIRLCollateFunction.cj_contrast
        • PIRLCollateFunction.cj_sat
        • PIRLCollateFunction.cj_hue
        • PIRLCollateFunction.min_scale
        • PIRLCollateFunction.random_gray_scale
        • PIRLCollateFunction.hf_prob
        • PIRLCollateFunction.n_grid
        • PIRLCollateFunction.normalize
        • PIRLCollateFunction.forward()
      • SMoGCollateFunction
        • SMoGCollateFunction.crop_sizes
        • SMoGCollateFunction.crop_counts
        • SMoGCollateFunction.crop_min_scales
        • SMoGCollateFunction.crop_max_scales
        • SMoGCollateFunction.gaussian_blur_probs
        • SMoGCollateFunction.gaussian_blur_kernel_sizes
        • SMoGCollateFunction.gaussian_blur_sigmas
        • SMoGCollateFunction.solarize_probs
        • SMoGCollateFunction.hf_prob
        • SMoGCollateFunction.cj_prob
        • SMoGCollateFunction.cj_strength
        • SMoGCollateFunction.random_gray_scale
        • SMoGCollateFunction.normalize
      • SimCLRCollateFunction
        • SimCLRCollateFunction.input_size
        • SimCLRCollateFunction.cj_prob
        • SimCLRCollateFunction.cj_strength
        • SimCLRCollateFunction.min_scale
        • SimCLRCollateFunction.random_gray_scale
        • SimCLRCollateFunction.gaussian_blur
        • SimCLRCollateFunction.kernel_size
        • SimCLRCollateFunction.sigmas
        • SimCLRCollateFunction.vf_prob
        • SimCLRCollateFunction.hf_prob
        • SimCLRCollateFunction.rr_prob
        • SimCLRCollateFunction.rr_degrees
        • SimCLRCollateFunction.normalize
      • SwaVCollateFunction
        • SwaVCollateFunction.crop_sizes
        • SwaVCollateFunction.crop_counts
        • SwaVCollateFunction.crop_min_scales
        • SwaVCollateFunction.crop_max_scales
        • SwaVCollateFunction.hf_prob
        • SwaVCollateFunction.vf_prob
        • SwaVCollateFunction.rr_prob
        • SwaVCollateFunction.rr_degrees
        • SwaVCollateFunction.cj_prob
        • SwaVCollateFunction.cj_strength
        • SwaVCollateFunction.random_gray_scale
        • SwaVCollateFunction.gaussian_blur
        • SwaVCollateFunction.kernel_size
        • SwaVCollateFunction.sigmas
        • SwaVCollateFunction.normalize
      • VICRegCollateFunction
        • VICRegCollateFunction.input_size
        • VICRegCollateFunction.cj_prob
        • VICRegCollateFunction.cj_bright
        • VICRegCollateFunction.cj_contrast
        • VICRegCollateFunction.cj_sat
        • VICRegCollateFunction.cj_hue
        • VICRegCollateFunction.min_scale
        • VICRegCollateFunction.random_gray_scale
        • VICRegCollateFunction.solarize_prob
        • VICRegCollateFunction.gaussian_blur
        • VICRegCollateFunction.kernel_size
        • VICRegCollateFunction.sigmas
        • VICRegCollateFunction.vf_prob
        • VICRegCollateFunction.hf_prob
        • VICRegCollateFunction.rr_prob
        • VICRegCollateFunction.rr_degrees
        • VICRegCollateFunction.normalize
      • VICRegLCollateFunction
        • VICRegLCollateFunction.global_crop_size
        • VICRegLCollateFunction.local_crop_size
        • VICRegLCollateFunction.global_crop_scale
        • VICRegLCollateFunction.local_crop_scale
        • VICRegLCollateFunction.global_grid_size
        • VICRegLCollateFunction.local_grid_size
        • VICRegLCollateFunction.global_gaussian_blur_prob
        • VICRegLCollateFunction.local_gaussian_blur_prob
        • VICRegLCollateFunction.global_gaussian_blur_kernel_size
        • VICRegLCollateFunction.local_gaussian_blur_kernel_size
        • VICRegLCollateFunction.global_gaussian_blur_sigmas
        • VICRegLCollateFunction.local_gaussian_blur_sigmas
        • VICRegLCollateFunction.global_solarize_prob
        • VICRegLCollateFunction.local_solarize_prob
        • VICRegLCollateFunction.hf_prob
        • VICRegLCollateFunction.cj_prob
        • VICRegLCollateFunction.cj_strength
        • VICRegLCollateFunction.random_gray_scale
        • VICRegLCollateFunction.normalize
        • VICRegLCollateFunction.forward()
  • lightly.loss
    • BarlowTwinsLoss
      • BarlowTwinsLoss.forward()
    • DCLLoss
      • DCLLoss.temperature
      • DCLLoss.weight_fn
      • DCLLoss.gather_distributed
      • DCLLoss.forward()
    • DCLWLoss
      • DCLWLoss.temperature
      • DCLWLoss.sigma
      • DCLWLoss.gather_distributed
    • DINOLoss
      • DINOLoss.output_dim
      • DINOLoss.warmup_teacher_temp
      • DINOLoss.teacher_temp
      • DINOLoss.warmup_teacher_temp_epochs
      • DINOLoss.student_temp
      • DINOLoss.center_momentum
      • DINOLoss.forward()
      • DINOLoss.update_center()
    • HypersphereLoss
      • HypersphereLoss.forward()
    • IBOTPatchLoss
      • IBOTPatchLoss.output_dim
      • IBOTPatchLoss.teacher_temp
      • IBOTPatchLoss.student_temp
      • IBOTPatchLoss.center_mode
      • IBOTPatchLoss.center_momentum
      • IBOTPatchLoss.forward()
    • KoLeoLoss
      • KoLeoLoss.p
      • KoLeoLoss.eps
      • KoLeoLoss.forward()
    • MemoryBankModule
      • MemoryBankModule.size
      • MemoryBankModule.gather_distributed
      • MemoryBankModule.feature_dim_first
      • MemoryBankModule.forward()
    • MMCRLoss
      • MMCRLoss.forward()
    • MSNLoss
      • MSNLoss.temperature
      • MSNLoss.sinkhorn_iterations
      • MSNLoss.regularization_weight
      • MSNLoss.me_max_weight
      • MSNLoss.gather_distributed
      • MSNLoss.forward()
      • MSNLoss.regularization_loss()
    • NegativeCosineSimilarity
      • NegativeCosineSimilarity.forward()
    • NTXentLoss
      • NTXentLoss.temperature
      • NTXentLoss.memory_bank_size
      • NTXentLoss.gather_distributed
      • NTXentLoss.forward()
    • PMSNLoss
      • PMSNLoss.temperature
      • PMSNLoss.sinkhorn_iterations
      • PMSNLoss.regularization_weight
      • PMSNLoss.power_law_exponent
      • PMSNLoss.gather_distributed
      • PMSNLoss.regularization_loss()
    • PMSNCustomLoss
      • PMSNCustomLoss.target_distribution
      • PMSNCustomLoss.temperature
      • PMSNCustomLoss.sinkhorn_iterations
      • PMSNCustomLoss.regularization_weight
      • PMSNCustomLoss.gather_distributed
      • PMSNCustomLoss.regularization_loss()
    • CO2Regularizer
      • CO2Regularizer.alpha
      • CO2Regularizer.t_consistency
      • CO2Regularizer.memory_bank_size
      • CO2Regularizer.forward()
    • SwaVLoss
      • SwaVLoss.temperature
      • SwaVLoss.sinkhorn_iterations
      • SwaVLoss.sinkhorn_epsilon
      • SwaVLoss.sinkhorn_gather_distributed
      • SwaVLoss.forward()
      • SwaVLoss.subloss()
    • SymNegCosineSimilarityLoss
      • SymNegCosineSimilarityLoss.forward()
    • TiCoLoss
      • TiCoLoss.Args
      • TiCoLoss.forward()
    • VICRegLoss
      • VICRegLoss.lambda_param
      • VICRegLoss.mu_param
      • VICRegLoss.nu_param
      • VICRegLoss.gather_distributed
      • VICRegLoss.eps
      • VICRegLoss.forward()
    • VICRegLLoss
      • VICRegLLoss.lambda_param
      • VICRegLLoss.mu_param
      • VICRegLLoss.nu_param
      • VICRegLLoss.alpha
      • VICRegLLoss.gather_distributed
      • VICRegLLoss.eps
      • VICRegLLoss.num_matches
      • VICRegLLoss.forward()
  • lightly.models
    • .resnet
      • BasicBlock
        • BasicBlock.in_planes
        • BasicBlock.planes
        • BasicBlock.stride
        • BasicBlock.forward()
      • Bottleneck
        • Bottleneck.in_planes
        • Bottleneck.planes
        • Bottleneck.stride
        • Bottleneck.forward()
      • ResNet
        • ResNet.block
        • ResNet.layers
        • ResNet.num_classes
        • ResNet.width
        • ResNet.forward()
      • ResNetGenerator()
    • .zoo
      • checkpoints()
    • .nn_memory_bank
      • NNMemoryBankModule
        • NNMemoryBankModule.size
        • NNMemoryBankModule.forward()
    • .heads
      • BYOLPredictionHead
      • BYOLProjectionHead
      • BarlowTwinsProjectionHead
      • DINOProjectionHead
        • DINOProjectionHead.input_dim
        • DINOProjectionHead.hidden_dim
        • DINOProjectionHead.bottleneck_dim
        • DINOProjectionHead.output_dim
        • DINOProjectionHead.batch_norm
        • DINOProjectionHead.freeze_last_layer
        • DINOProjectionHead.norm_last_layer
        • DINOProjectionHead.cancel_last_layer_gradients()
        • DINOProjectionHead.forward()
      • DenseCLProjectionHead
      • MMCRProjectionHead
      • MSNProjectionHead
        • MSNProjectionHead.input_dim
        • MSNProjectionHead.hidden_dim
        • MSNProjectionHead.output_dim
      • MoCoProjectionHead
      • NNCLRPredictionHead
      • NNCLRProjectionHead
      • ProjectionHead
        • ProjectionHead.forward()
      • SMoGPredictionHead
      • SMoGProjectionHead
      • SMoGPrototypes
        • SMoGPrototypes.assign_groups()
        • SMoGPrototypes.forward()
        • SMoGPrototypes.get_updated_group_features()
        • SMoGPrototypes.set_group_features()
      • SimCLRProjectionHead
      • SimSiamPredictionHead
      • SimSiamProjectionHead
      • SwaVProjectionHead
      • SwaVPrototypes
        • SwaVPrototypes.input_dim
        • SwaVPrototypes.n_prototypes
        • SwaVPrototypes.n_steps_frozen_prototypes
        • SwaVPrototypes.forward()
        • SwaVPrototypes.normalize()
      • TiCoProjectionHead
      • VICRegProjectionHead
      • VicRegLLocalProjectionHead
  • lightly.transforms
    • DenseCLTransform
      • DenseCLTransform.input_size
      • DenseCLTransform.cj_prob
      • DenseCLTransform.cj_strength
      • DenseCLTransform.cj_bright
      • DenseCLTransform.cj_contrast
      • DenseCLTransform.cj_sat
      • DenseCLTransform.cj_hue
      • DenseCLTransform.min_scale
      • DenseCLTransform.random_gray_scale
      • DenseCLTransform.gaussian_blur
      • DenseCLTransform.kernel_size
      • DenseCLTransform.sigmas
      • DenseCLTransform.vf_prob
      • DenseCLTransform.hf_prob
      • DenseCLTransform.rr_prob
      • DenseCLTransform.rr_degrees
      • DenseCLTransform.normalize
    • DINOTransform
      • DINOTransform.global_crop_size
      • DINOTransform.global_crop_scale
      • DINOTransform.local_crop_size
      • DINOTransform.local_crop_scale
      • DINOTransform.n_local_views
      • DINOTransform.hf_prob
      • DINOTransform.vf_prob
      • DINOTransform.rr_prob
      • DINOTransform.rr_degrees
      • DINOTransform.cj_prob
      • DINOTransform.cj_strength
      • DINOTransform.cj_bright
      • DINOTransform.cj_contrast
      • DINOTransform.cj_sat
      • DINOTransform.cj_hue
      • DINOTransform.random_gray_scale
      • DINOTransform.gaussian_blur
      • DINOTransform.kernel_size
      • DINOTransform.kernel_scale
      • DINOTransform.sigmas
      • DINOTransform.solarization
      • DINOTransform.normalize
    • FastSiamTransform
      • FastSiamTransform.num_views
      • FastSiamTransform.input_size
      • FastSiamTransform.cj_prob
      • FastSiamTransform.cj_strength
      • FastSiamTransform.cj_bright
      • FastSiamTransform.cj_contrast
      • FastSiamTransform.cj_sat
      • FastSiamTransform.cj_hue
      • FastSiamTransform.min_scale
      • FastSiamTransform.random_gray_scale
      • FastSiamTransform.gaussian_blur
      • FastSiamTransform.kernel_size
      • FastSiamTransform.sigmas
      • FastSiamTransform.vf_prob
      • FastSiamTransform.hf_prob
      • FastSiamTransform.rr_prob
      • FastSiamTransform.rr_degrees
      • FastSiamTransform.normalize
    • GaussianBlur
      • GaussianBlur.kernel_size
      • GaussianBlur.prob
      • GaussianBlur.scale
      • GaussianBlur.sigmas
      • GaussianBlur.__call__()
    • ImageGridTransform
      • ImageGridTransform.transforms
      • ImageGridTransform.__call__()
    • Jigsaw
      • Jigsaw.n_grid
      • Jigsaw.img_size
      • Jigsaw.crop_size
      • Jigsaw.transform
      • Jigsaw.__call__()
    • MAETransform
      • MAETransform.input_size
      • MAETransform.min_scale
      • MAETransform.normalize
      • MAETransform.__call__()
    • MMCRTransform
      • MMCRTransform.k
      • MMCRTransform.transform
    • MoCoV1Transform
      • MoCoV1Transform.input_size
      • MoCoV1Transform.cj_prob
      • MoCoV1Transform.cj_strength
      • MoCoV1Transform.cj_bright
      • MoCoV1Transform.cj_contrast
      • MoCoV1Transform.cj_sat
      • MoCoV1Transform.cj_hue
      • MoCoV1Transform.min_scale
      • MoCoV1Transform.random_gray_scale
      • MoCoV1Transform.gaussian_blur
      • MoCoV1Transform.kernel_size
      • MoCoV1Transform.sigmas
      • MoCoV1Transform.vf_prob
      • MoCoV1Transform.hf_prob
      • MoCoV1Transform.rr_prob
      • MoCoV1Transform.rr_degrees
      • MoCoV1Transform.normalize
    • MoCoV2Transform
      • MoCoV2Transform.input_size
      • MoCoV2Transform.cj_prob
      • MoCoV2Transform.cj_strength
      • MoCoV2Transform.cj_bright
      • MoCoV2Transform.cj_contrast
      • MoCoV2Transform.cj_sat
      • MoCoV2Transform.cj_hue
      • MoCoV2Transform.min_scale
      • MoCoV2Transform.random_gray_scale
      • MoCoV2Transform.gaussian_blur
      • MoCoV2Transform.kernel_size
      • MoCoV2Transform.sigmas
      • MoCoV2Transform.vf_prob
      • MoCoV2Transform.hf_prob
      • MoCoV2Transform.rr_prob
      • MoCoV2Transform.rr_degrees
      • MoCoV2Transform.normalize
    • MSNTransform
      • MSNTransform.random_size
      • MSNTransform.focal_size
      • MSNTransform.random_views
      • MSNTransform.focal_views
      • MSNTransform.random_crop_scale
      • MSNTransform.focal_crop_scale
      • MSNTransform.cj_prob
      • MSNTransform.cj_strength
      • MSNTransform.cj_bright
      • MSNTransform.cj_contrast
      • MSNTransform.cj_sat
      • MSNTransform.cj_hue
      • MSNTransform.gaussian_blur
      • MSNTransform.kernel_size
      • MSNTransform.sigmas
      • MSNTransform.random_gray_scale
      • MSNTransform.hf_prob
      • MSNTransform.vf_prob
      • MSNTransform.normalize
    • MultiCropTranform
      • MultiCropTranform.crop_sizes
      • MultiCropTranform.crop_counts
      • MultiCropTranform.crop_min_scales
      • MultiCropTranform.crop_max_scales
      • MultiCropTranform.transforms
    • MultiViewTransform
      • MultiViewTransform.__call__()
    • PIRLTransform
      • PIRLTransform.input_size
      • PIRLTransform.cj_prob
      • PIRLTransform.cj_strength
      • PIRLTransform.cj_bright
      • PIRLTransform.cj_contrast
      • PIRLTransform.cj_sat
      • PIRLTransform.cj_hue
      • PIRLTransform.min_scale
      • PIRLTransform.random_gray_scale
      • PIRLTransform.hf_prob
      • PIRLTransform.n_grid
      • PIRLTransform.normalize
    • Location
    • RandomHorizontalFlipWithLocation
      • RandomHorizontalFlipWithLocation.forward()
    • RandomResizedCropAndFlip
      • RandomResizedCropAndFlip.forward()
      • RandomResizedCropAndFlip.location_to_NxN_grid()
    • RandomResizedCropWithLocation
      • RandomResizedCropWithLocation.forward()
    • RandomVerticalFlipWithLocation
      • RandomVerticalFlipWithLocation.forward()
    • RandomRotate
      • RandomRotate.prob
      • RandomRotate.angle
      • RandomRotate.__call__()
    • RandomRotateDegrees
      • RandomRotateDegrees.prob
      • RandomRotateDegrees.degrees
      • RandomRotateDegrees.__call__()
    • SimCLRTransform
      • SimCLRTransform.input_size
      • SimCLRTransform.cj_prob
      • SimCLRTransform.cj_strength
      • SimCLRTransform.cj_bright
      • SimCLRTransform.cj_contrast
      • SimCLRTransform.cj_sat
      • SimCLRTransform.cj_hue
      • SimCLRTransform.min_scale
      • SimCLRTransform.random_gray_scale
      • SimCLRTransform.gaussian_blur
      • SimCLRTransform.kernel_size
      • SimCLRTransform.sigmas
      • SimCLRTransform.vf_prob
      • SimCLRTransform.hf_prob
      • SimCLRTransform.rr_prob
      • SimCLRTransform.rr_degrees
      • SimCLRTransform.normalize
    • SimSiamTransform
      • SimSiamTransform.input_size
      • SimSiamTransform.cj_prob
      • SimSiamTransform.cj_strength
      • SimSiamTransform.cj_bright
      • SimSiamTransform.cj_contrast
      • SimSiamTransform.cj_sat
      • SimSiamTransform.cj_hue
      • SimSiamTransform.min_scale
      • SimSiamTransform.random_gray_scale
      • SimSiamTransform.gaussian_blur
      • SimSiamTransform.kernel_size
      • SimSiamTransform.sigmas
      • SimSiamTransform.vf_prob
      • SimSiamTransform.hf_prob
      • SimSiamTransform.rr_prob
      • SimSiamTransform.rr_degrees
      • SimSiamTransform.normalize
    • SMoGTransform
      • SMoGTransform.crop_sizes
      • SMoGTransform.crop_counts
      • SMoGTransform.crop_min_scales
      • SMoGTransform.crop_max_scales
      • SMoGTransform.gaussian_blur_probs
      • SMoGTransform.gaussian_blur_kernel_sizes
      • SMoGTransform.gaussian_blur_sigmas
      • SMoGTransform.solarize_probs
      • SMoGTransform.hf_prob
      • SMoGTransform.cj_prob
      • SMoGTransform.cj_strength
      • SMoGTransform.cj_bright
      • SMoGTransform.cj_contrast
      • SMoGTransform.cj_sat
      • SMoGTransform.cj_hue
      • SMoGTransform.random_gray_scale
      • SMoGTransform.normalize
    • RandomSolarization
      • RandomSolarization.probability
      • RandomSolarization.threshold
      • RandomSolarization.__call__()
    • SwaVTransform
      • SwaVTransform.crop_sizes
      • SwaVTransform.crop_counts
      • SwaVTransform.crop_min_scales
      • SwaVTransform.crop_max_scales
      • SwaVTransform.hf_prob
      • SwaVTransform.vf_prob
      • SwaVTransform.rr_prob
      • SwaVTransform.rr_degrees
      • SwaVTransform.cj_prob
      • SwaVTransform.cj_strength
      • SwaVTransform.cj_bright
      • SwaVTransform.cj_contrast
      • SwaVTransform.cj_sat
      • SwaVTransform.cj_hue
      • SwaVTransform.random_gray_scale
      • SwaVTransform.gaussian_blur
      • SwaVTransform.kernel_size
      • SwaVTransform.sigmas
      • SwaVTransform.normalize
    • VICRegTransform
      • VICRegTransform.input_size
      • VICRegTransform.cj_prob
      • VICRegTransform.cj_strength
      • VICRegTransform.cj_bright
      • VICRegTransform.cj_contrast
      • VICRegTransform.cj_sat
      • VICRegTransform.cj_hue
      • VICRegTransform.min_scale
      • VICRegTransform.random_gray_scale
      • VICRegTransform.solarize_prob
      • VICRegTransform.gaussian_blur
      • VICRegTransform.kernel_size
      • VICRegTransform.sigmas
      • VICRegTransform.vf_prob
      • VICRegTransform.hf_prob
      • VICRegTransform.rr_prob
      • VICRegTransform.rr_degrees
      • VICRegTransform.normalize
    • VICRegLTransform
      • VICRegLTransform.global_crop_size
      • VICRegLTransform.local_crop_size
      • VICRegLTransform.n_global_views
      • VICRegLTransform.n_local_views
      • VICRegLTransform.global_crop_scale
      • VICRegLTransform.local_crop_scale
      • VICRegLTransform.global_grid_size
      • VICRegLTransform.local_grid_size
      • VICRegLTransform.global_gaussian_blur_prob
      • VICRegLTransform.local_gaussian_blur_prob
      • VICRegLTransform.global_gaussian_blur_kernel_size
      • VICRegLTransform.local_gaussian_blur_kernel_size
      • VICRegLTransform.global_gaussian_blur_sigmas
      • VICRegLTransform.local_gaussian_blur_sigmas
      • VICRegLTransform.global_solarize_prob
      • VICRegLTransform.local_solarize_prob
      • VICRegLTransform.hf_prob
      • VICRegLTransform.cj_prob
      • VICRegLTransform.cj_strength
      • VICRegLTransform.cj_bright
      • VICRegLTransform.cj_contrast
      • VICRegLTransform.cj_sat
      • VICRegLTransform.cj_hue
      • VICRegLTransform.random_gray_scale
      • VICRegLTransform.normalize
  • lightly.utils
    • .io
      • check_embeddings()
      • load_embeddings()
      • load_embeddings_as_dict()
      • save_embeddings()
      • save_schema()
      • save_tasks()
    • .embeddings_2d
      • PCA
        • PCA.n_components
        • PCA.eps
        • PCA.mean
        • PCA.w
        • PCA.fit()
        • PCA.transform()
      • fit_pca()
    • .benchmarking
    • .debug
      • apply_transform_without_normalize()
      • generate_grid_of_augmented_images()
      • plot_augmented_images()
      • std_of_l2_normalized()
    • .dist
      • GatherLayer
        • GatherLayer.backward()
        • GatherLayer.forward()
      • eye_rank()
      • gather()
      • rank()
      • rank_zero_only()
      • world_size()
    • .reordering
      • sort_items_by_keys()
    • .version_compare
      • version_compare()

On-Premise

  • Docker Archive
    • Setup
      • Analytics
      • Licensing
      • Download the Docker Image
      • Sanity Check
      • Update Lightly Docker
    • First Steps
      • Storage Access
      • Specify Relevant Files
      • Embedding a Dataset and Selecting from it
      • Train a Self-Supervised Model
      • Accessing Lightly Input Parameters
      • Selecting from Embeddings File
      • Manually Inspecting the Embeddings
      • Selecting from Video Files
      • Removing Exact Duplicates
      • Upload Sampled Dataset To Lightly Platform
      • Reporting
        • Live View of Docker Status
        • Docker Output
        • Evaluation of the Selection Proces
    • Advanced
      • Meta Information
        • Mask Samples
        • Use Pre-Selected Samples
        • Custom Weak Labels
      • Datapool
        • How It Works
        • Usage
      • Pretagging
        • How It Works
        • Usage
      • Add Predictions to a Datasource
        • Predictions Folder Structure
        • Prediction Tasks
        • Prediction Schema
        • Prediction Files
        • Prediction Files for Videos
        • Prediction Format
        • Prediction Singletons
        • Creating the predictions folder
      • Add Metadata to a Datasource
        • Metadata Folder Structure
        • Metadata Schema
        • Metadata Files
        • Metadata Format
        • Next Steps
      • Active Learning
        • Prerequisites
        • Selection
        • Active Learning with Custom Scores (not recommended as of March 2022)
      • Sequence Selection
        • How It Works
        • Usage
      • Object Level
        • Prerequisites
        • Predictions
        • Selection on Object Level
        • Lightly Pretagging
        • Padding
        • Object Crops Dataset
        • Analyzing the Crop Dataset
        • Multiple Object Level Runs
    • Integration
      • Using the Docker with a Cloud Bucket as Remote Datasource
        • Introduction
        • Advantages
        • Requirements
        • Download the Lightly Docker
        • Run the Lightly Docker with the datasource
        • View the progress of the Lightly Docker
        • Use your selected dataset
        • Process new data in your bucket using a datapool
        • Network traffic
      • Trigger a Docker Job from from the Platform or code
        • Introduction
        • Advantages
        • Download the Lightly Docker
        • Register the Lightly Docker as a Worker
        • Create a Dataset and Trigger a Job
        • View the progress of the Lightly Docker
        • Use your selected dataset
        • Process new data in your bucket using a datapool
      • Load data directly from S3 buckets using s3fs-fuse
        • What is s3fs-fuse?
        • Get an AWS Bucket and Credentials
        • Install s3fs-fuse
        • Configure S3 Credentials
        • Use S3 Storage with Lightly Docker
        • Use Caching
        • Common Issues
      • Data Pre-processing Pipeline on AWS with Dagster
        • Introduction
        • Dagster
        • Setting up the EC2 Instance
        • Setting up the S3 Bucket
        • Integration
    • Configuration
      • List of Parameters
      • Choosing the Right Parameters
      • Increase I/O Performance
    • Examples
      • Extract Diverse Video Frames
        • Using ffmpeg
        • Using Lightly Docker
      • ImageNet
      • Combining Cityscapes with Kitti
    • Known Issues and FAQ
      • Docker is slow when working with long videos
      • Docker Crashes when running with GPUs
      • Shared Memory Error when running Lightly Worker
      • Docker crashes because of too many open files
      • Permission denied for input created with sudo
      • Error when using S3 fuse and mounting to docker
      • Token printed to shared stdout or logs
    • Hardware recommendations
      • Finding the compute speed bottleneck
      • Updating the machine
lightly
Looking to easily do active learning on millions of samples? See our Lighly Worker docs.
  • Search

© Copyright 2020-  | Lightly AG  |  LightlySSL source code Source Code  | Lightly Worker Solution documentation

Built with Sphinx using a theme provided by Read the Docs.