graft-pytorch 0.1.7__py3-none-any.whl

graft/utils/loader.py

@@ -0,0 +1,293 @@
+import torchvision
+import torchvision.transforms as transforms
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+from sklearn.model_selection import train_test_split
+import os
+import PIL.Image as Image
+
+class CustomDataset(Dataset):
+    def __init__(self, data, target, device=None, transform=None, isreg=False):
+        self.transform = transform
+        self.isreg = isreg
+        if device is not None:
+            # Push the entire data to given device, eg: cuda:0
+            self.data = data.float().to(device)
+            if isreg:
+                self.targets = target.float().to(device)
+            else:
+                self.targets = target.long().to(device)
+
+        else:
+            self.data = data.float()
+            if isreg:
+                self.targets = target.float()
+            else:
+                self.targets = target.long()
+
+    def __len__(self):
+        return len(self.targets)
+
+    def __getitem__(self, idx):
+        if torch.is_tensor(idx):
+            idx = idx.tolist()
+        sample_data = self.data[idx]
+        label = self.targets[idx]
+        if self.transform is not None:
+            sample_data = self.transform(sample_data)
+        return (sample_data, label)  # .astype('float32')
+
+class standard_scaling:
+    def __init__(self):
+        self.std = None
+        self.mean = None
+
+    def fit_transform(self, data):
+        self.std = np.std(data, axis=0)
+        self.mean = np.mean(data, axis=0)
+        transformed_data = np.subtract(data, self.mean)
+        transformed_data = np.divide(transformed_data, self.std)
+        return transformed_data
+
+    def transform(self, data):
+        transformed_data = np.subtract(data, self.mean)
+        transformed_data = np.divide(transformed_data, self.std)
+        return transformed_data
+    
+# class TinyImageNetDataset(Dataset):
+#     def __init__(self, root_dir, split='train', transform=None):
+#         """
+#         Args:
+#             root_dir (string): Directory with all the images.
+#             split (string): Either 'train', 'val', or 'test'.
+#             transform (callable, optional): Optional transform to be applied
+#                 on a sample.
+#         """
+#         self.root_dir = root_dir
+#         self.split = split
+#         self.transform = transform
+#         self.classes = os.listdir(os.path.join(root_dir, split))
+#         self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+#         self.class_name = self._get_names()
+#         self.images = self._load_images()
+
+#     def _load_images(self):
+#         images = []
+#         for cls in self.classes:
+#             cls_dir = os.path.join(self.root_dir, self.split, cls, 'images')
+#             for image_file in os.listdir(cls_dir):
+#                 image_path = os.path.join(cls_dir, image_file)
+#                 images.append((image_path, self.class_to_idx[cls]))
+#         return images
+
+#     def __len__(self):
+#         return len(self.images)
+
+#     def __getitem__(self, idx):
+#         img_path, label = self.images[idx]
+#         image = Image.open(img_path).convert('RGB')
+#         if self.transform:
+#             image = self.transform(image)
+#         return image, label
+
+#     def _get_names(self):
+#         entity_dict = {}
+#         # Open the text file
+#         with open('tiny-imagenet-200/words.txt', 'r') as file:
+#             # Read each line
+#             for line in file:
+#                 # Split the line into key and value using tab ('\t') as delimiter
+#                 key, value = line.strip().split('\t')
+        
+#                 first = value.strip().split(',')
+#                 # Add the key-value pair to the dictionary
+#                 entity_dict[key] = first[0]
+#                 # entity_dict.append(line)
+#         return entity_dict
+
+class TinyImageNet(Dataset):
+    def __init__(self, root, split='train', transform=None):
+        """
+        Args:
+            root_dir (string): Directory with all the images.
+            split (string): Either 'train', 'val', or 'test'.
+            transform (callable, optional): Optional transform to be applied
+                on a sample.
+        """
+        self.root_dir = root
+#         self.root_dir = os.path.join(root, main_dir) 
+        self.split = split
+        self.transform = transform
+        self.classes = []
+        with open(os.path.join(self.root_dir, 'wnids.txt'), 'r') as f:
+            self.classes = f.read().strip().split()
+        self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+        
+        # self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+        self.class_name = self._get_names()
+        self.images = self._load_images()        
+        # self.repl_str = str_out
+
+    def _load_images(self):
+        images = []
+        if self.split == 'train':
+            for cls in self.classes:
+                cls_dir = os.path.join(self.root_dir, self.split, cls, 'images')
+                for image_file in os.listdir(cls_dir):
+                    image_path = os.path.join(cls_dir, image_file)
+                    images.append((image_path, self.class_to_idx[cls]))
+                    
+        elif self.split == 'val':
+            val_dir = os.path.join(self.root_dir, self.split, 'images')
+            image_to_cls = {}
+            with open(os.path.join(self.root_dir, self.split, 'val_annotations.txt'), 'r') as f:
+                for line in f.read().strip().split('\n'):
+                    # print(line)
+                    image_to_cls[line.split()[0].strip()] = line.split()[1].strip()                  
+            for image_file in os.listdir(val_dir):
+                # print(image_file)
+                image_path = os.path.join(val_dir, image_file)
+                images.append((image_path, self.class_to_idx[image_to_cls[image_file]]))
+                
+            # for cls in self.classes:
+            #     cls_dir = os.path.join(self.root_dir, self.split, cls, 'images')
+            #     for image_file in os.listdir(cls_dir):
+            #         image_path = os.path.join(cls_dir, image_file)
+            #         images.append((image_path, self.class_to_idx[cls]))
+            
+        return images
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, idx):
+        img_path, label = self.images[idx]
+        image = Image.open(img_path).convert('RGB')
+        if self.transform:
+            image = self.transform(image)
+        return image, label
+
+    def _get_names(self):
+        entity_dict = {}
+        # Open the text file
+        with open(os.path.join(self.root_dir, 'words.txt'), 'r') as file:
+            # Read each line
+            for line in file:
+                # Split the line into key and value using tab ('\t') as delimiter
+                key, value = line.strip().split('\t')
+                first = value.strip().split(',')
+                # Add the key-value pair to the dictionary
+                entity_dict[key] = first[0]
+        return entity_dict
+
+
+def loader(dataset, dirs="./cifar10", trn_batch_size=64, val_batch_size=64, tst_batch_size=1000):
+    """Load and return data loaders for the specified dataset"""
+    
+    if dataset.lower() == "cifar10":
+        transform_train = transforms.Compose([
+            transforms.RandomCrop(32, padding=4),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+        ])
+
+        transform_test = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+        ])
+
+        trainset = torchvision.datasets.CIFAR10(
+            root='./data', train=True, download=True, transform=transform_train)
+        trainloader = torch.utils.data.DataLoader(
+            trainset, batch_size=trn_batch_size, shuffle=True, num_workers=2)
+
+        testset = torchvision.datasets.CIFAR10(
+            root='./data', train=False, download=True, transform=transform_test)
+        testloader = torch.utils.data.DataLoader(
+            testset, batch_size=tst_batch_size, shuffle=False, num_workers=2)
+        
+        return trainloader, testloader, trainset, testset
+        
+    elif dataset.lower() == "cifar100":
+        transform_train = transforms.Compose([
+            transforms.RandomCrop(32, padding=4),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize((0.5071, 0.4867, 0.4408), (0.2675, 0.2565, 0.2761)),
+        ])
+
+        transform_test = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.5071, 0.4867, 0.4408), (0.2675, 0.2565, 0.2761)),
+        ])
+
+        trainset = torchvision.datasets.CIFAR100(
+            root='./data', train=True, download=True, transform=transform_train)
+        trainloader = torch.utils.data.DataLoader(
+            trainset, batch_size=trn_batch_size, shuffle=True, num_workers=2)
+
+        testset = torchvision.datasets.CIFAR100(
+            root='./data', train=False, download=True, transform=transform_test)
+        testloader = torch.utils.data.DataLoader(
+            testset, batch_size=tst_batch_size, shuffle=False, num_workers=2)
+        
+        return trainloader, testloader, trainset, testset
+        
+    elif dataset.lower() == "imagenet":
+        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                     std=[0.229, 0.224, 0.225])
+        
+        train_transform = transforms.Compose([
+            transforms.RandomResizedCrop(224),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            normalize,
+        ])
+        
+        val_transform = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            normalize,
+        ])
+        
+        train_dir = os.path.join(dirs, 'train')
+        val_dir = os.path.join(dirs, 'val')
+        
+        train_dataset = torchvision.datasets.ImageFolder(
+            train_dir,
+            train_transform
+        )
+        
+        val_dataset = torchvision.datasets.ImageFolder(
+            val_dir,
+            val_transform
+        )
+        
+        train_loader = torch.utils.data.DataLoader(
+            train_dataset, batch_size=trn_batch_size, shuffle=True,
+            num_workers=4, pin_memory=True
+        )
+        
+        val_loader = torch.utils.data.DataLoader(
+            val_dataset, batch_size=val_batch_size, shuffle=False,
+            num_workers=4, pin_memory=True
+        )
+        
+        return train_loader, val_loader, train_dataset, val_dataset
+    
+    else:
+        raise ValueError(f"Dataset {dataset} not supported")
+
+if __name__ == "__main__":
+    # Run some basic tests
+    try:
+        # Test CIFAR10
+        train_l, test_l, train_s, test_s = loader("cifar10")
+        # Test CIFAR100 
+        train_l, test_l, train_s, test_s = loader("cifar100")
+        print("✓ All test cases passed successfully!")
+    except Exception as e:
+        print(f"✗ Test failed: {str(e)}")

graft/utils/model_mapper.py

@@ -0,0 +1,45 @@
+from ..models import ResNet18,ResNet50, EfficientNetB0, ResNet9, MobileNetV2, MobileNet, ResNet101, ResNet152, ResNeXt29_32x4d, ResNext50_32x4d, ResNext101_32x8d, ResNext101_64x4d, FashionCNN, bertmodel
+
+
+class ModelMapper:
+    def __init__(self, args):
+        self.args = args
+        self.model_mapping = {
+            "resnet18": ResNet18,
+            "resnet50": ResNet50,
+            "resnet9": ResNet9,
+            "mobilenetv2": MobileNetV2,
+            "mobilenet": MobileNet,
+            "resnet101": ResNet101,
+            "resnet152": ResNet152,
+            "efficientnetb0": EfficientNetB0,
+            "resnext": ResNeXt29_32x4d,
+            "resnext50": ResNext50_32x4d,
+            "resnext101_32": ResNext101_32x8d,
+            "resnext101_64": ResNext101_64x4d,
+            "fashioncnn": FashionCNN,
+#             "twolayernet": TwoLayerNet,
+#             "threelayernet": ThreeLayerNet,
+            "bert": bertmodel,
+        }
+
+        
+    def get_model(self):
+        # Get the model name from arguments and convert it to lowercase
+        
+        model_group1 = ["resnext", "resnet9", "fashioncnn", "twolayernet", "threelayernet"]
+        model_group2 = ["bert"]
+        
+        model_name = self.args.model.lower()
+        if model_name in self.model_mapping:
+            # Get the corresponding model class
+            model_class = self.model_mapping[model_name]
+            if model_name.lower() in model_group1:
+                return model_class(self.args.in_chanls, self.args.numClasses).to(self.args.device)
+            elif model_name.lower() in model_group2:
+                return model_class(self.args.device, self.args.numClasses).to(self.args.device)
+            else:
+                return model_class(self.args.numClasses).to(self.args.device)
+        else:
+            print("model not available at this moment")
+            

graft/utils/pickler.py

@@ -0,0 +1,27 @@
+import pickle
+import os
+
+class pickler():
+
+    def save_pickle(V, dirs, bs) -> None:
+        folder_name = f"{dirs}" + "_pickle"
+        if not os.path.exists(folder_name):
+            os.mkdir(folder_name)
+        
+        file = os.path.join(f"{dirs}" + "_pickle", f"V_{bs}.pkl") 
+        with open(file, 'wb') as f:
+             pickle.dump(V, f)
+                
+        if os.path.exists(file):
+            print("pickle saved successfully")
+        else:
+            print("Failed to save pickle.")
+
+
+    def load_pickle(dirs, bs):
+                
+        file = os.path.join(f"{dirs}" + "_pickle", f"V_{bs}.pkl") 
+
+        with open(file, 'rb') as f:
+            data3 = pickle.load(f)
+        return data3

graft_pytorch-0.1.7.dist-info/METADATA

@@ -0,0 +1,302 @@
+Metadata-Version: 2.4
+Name: graft-pytorch
+Version: 0.1.7
+Summary: Gradient-Aware Fast MaxVol Technique for Dynamic Data Sampling
+Home-page: https://github.com/ashishjv1/GRAFT
+Author: Ashish Jha
+Author-email: Ashish Jha <Ashish.Jha@skoltech.ru>
+Maintainer-email: Ashish Jha <Ashish.Jha@skoltech.ru>
+License: MIT
+Project-URL: Homepage, https://github.com/ashishjv1/GRAFT
+Project-URL: Repository, https://github.com/ashishjv1/GRAFT
+Project-URL: Bug Reports, https://github.com/ashishjv1/GRAFT/issues
+Project-URL: Documentation, https://github.com/ashishjv1/GRAFT/blob/main/README.md
+Keywords: machine-learning,deep-learning,pytorch,data-sampling,gradient-based-sampling
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=1.9.0
+Requires-Dist: torchvision>=0.10.0
+Requires-Dist: numpy>=1.19.2
+Requires-Dist: tqdm>=4.62.3
+Requires-Dist: scikit-learn>=0.24.2
+Requires-Dist: pillow>=8.3.1
+Requires-Dist: matplotlib>=3.4.3
+Requires-Dist: transformers>=4.0.0
+Requires-Dist: medmnist>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.2.5; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Provides-Extra: tracking
+Requires-Dist: wandb>=0.12.0; extra == "tracking"
+Requires-Dist: eco2ai>=1.0.0; extra == "tracking"
+Provides-Extra: all
+Requires-Dist: pytest>=6.2.5; extra == "all"
+Requires-Dist: pytest-cov; extra == "all"
+Requires-Dist: black; extra == "all"
+Requires-Dist: isort; extra == "all"
+Requires-Dist: flake8; extra == "all"
+Requires-Dist: wandb>=0.12.0; extra == "all"
+Requires-Dist: eco2ai>=1.0.0; extra == "all"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# GRAFT: Gradient-Aware Fast MaxVol Technique for Dynamic Data Sampling
+
+[![PyPI version](https://badge.fury.io/py/graft-pytorch.svg)](https://badge.fury.io/py/graft-pytorch)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A PyTorch implementation of smart sampling for efficient deep learning training.
+
+## Overview
+GRAFT uses gradient information and feature decomposition to select the most informative samples during training, reducing computation time while maintaining model performance.
+
+## Features
+- **Smart sample selection** using gradient-based importance scoring
+- **Multi-architecture support** (ResNet, ResNeXT, EfficientNet, BERT)
+- **Dataset compatibility** (CIFAR10/100, TinyImageNet, Caltech256, Medical datasets)
+- **Experiment tracking** with Weights & Biases integration
+- **Carbon footprint tracking** with eco2AI
+- **Efficient training** with reduced computational overhead
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install graft-pytorch
+```
+
+### With optional dependencies
+```bash
+# For experiment tracking
+pip install graft-pytorch[tracking]
+
+# For development
+pip install graft-pytorch[dev]
+
+# Everything
+pip install graft-pytorch[all]
+```
+
+### From Source
+```bash
+git clone https://github.com/ashishjv1/GRAFT.git
+cd GRAFT
+pip install -e .
+```
+
+## Quick Start
+
+### Command Line Interface
+```bash
+# Install and train with smart sampling
+pip install graft-pytorch
+
+# Basic training with GRAFT sampling on CIFAR-10
+graft-train \
+    --numEpochs=200 \
+    --batch_size=128 \
+    --device="cuda" \
+    --optimizer="sgd" \
+    --lr=0.1 \
+    --numClasses=10 \
+    --dataset="cifar10" \
+    --model="resnet18" \
+    --fraction=0.5 \
+    --select_iter=25 \
+    --warm_start
+```
+
+### Python API
+```python
+import torch
+from graft import ModelTrainer, TrainingConfig
+from graft.utils.loader import loader
+
+# Load your dataset
+trainloader, valloader, trainset, valset = loader(
+    dataset="cifar10",
+    trn_batch_size=128,
+    val_batch_size=128
+)
+
+# Configure training with GRAFT
+config = TrainingConfig(
+    numEpochs=100,
+    batch_size=128,
+    device="cuda" if torch.cuda.is_available() else "cpu",
+    model_name="resnet18",
+    dataset_name="cifar10",
+    trainloader=trainloader,
+    valloader=valloader,
+    trainset=trainset,
+    optimizer_name="sgd",
+    lr=0.1,
+    fraction=0.5,         # Use 50% of data per epoch
+    selection_iter=25,    # Reselect samples every 25 epochs
+    warm_start=True       # Train on full data initially
+)
+
+# Train with smart sampling
+trainer = ModelTrainer(config, trainloader, valloader, trainset)
+train_stats, val_stats = trainer.train()
+
+print(f"Best validation accuracy: {val_stats['best_acc']:.2%}")
+```
+
+### Advanced Usage
+```python
+from graft import feature_sel, sample_selection
+import torch.nn as nn
+
+# Custom model and data selection
+model = MyCustomModel()
+data3 = feature_sel(dataloader, batch_size=128, device="cuda")
+
+# Manual sample selection
+selected_indices = sample_selection(
+    dataloader, data3, model, model.state_dict(),
+    batch_size=128, fraction=0.3, select_iter=10,
+    numEpochs=200, device="cuda", dataset="custom"
+)
+```
+
+## Functionality Overview
+
+### Core Components
+
+#### 1. Smart Sample Selection
+- **`sample_selection()`**: Selects most informative samples using gradient-based importance
+- **`feature_sel()`**: Performs feature decomposition for efficient sampling
+- Reduces training time by 30-50% while maintaining model performance
+
+#### 2. Supported Models
+- **Vision Models**: ResNet, ResNeXt, EfficientNet, MobileNet, FashionCNN
+- **Language Models**: BERT for sequence classification
+- **Custom Models**: Easy integration with any PyTorch model
+
+#### 3. Dataset Support
+- **Computer Vision**: CIFAR-10/100, TinyImageNet, Caltech256
+- **Medical Imaging**: Integration with MedMNIST datasets  
+- **Custom Datasets**: Support for any PyTorch DataLoader
+
+#### 4. Training Features
+- **Dynamic Sampling**: Adaptive sample selection during training
+- **Warm Starting**: Begin with full dataset, then switch to sampling
+- **Experiment Tracking**: Built-in WandB integration
+- **Carbon Tracking**: Monitor environmental impact with eco2AI
+
+### Configuration Parameters
+
+| Parameter | Description | Default | Options |
+|-----------|-------------|---------|---------|
+| `numEpochs` | Training epochs | 200 | Any integer |
+| `batch_size` | Batch size | 128 | 32, 64, 128, 256+ |
+| `device` | Computing device | "cuda" | "cpu", "cuda" |
+| `model` | Model architecture | "resnet18" | "resnet18/50", "resnext", "efficientnet" |
+| `fraction` | Data sampling ratio | 0.5 | 0.1 - 1.0 |
+| `select_iter` | Reselection frequency | 25 | Any integer |
+| `optimizer` | Optimization algorithm | "sgd" | "sgd", "adam" |
+| `lr` | Learning rate | 0.1 | 0.001 - 0.1 |
+| `warm_start` | Use full data initially | False | True/False |
+| `decomp` | Decomposition backend | "numpy" | "numpy", "torch" |
+
+### Performance Benefits
+
+- **Speed**: 30-50% faster training time
+- **Memory**: Reduced memory usage through smart sampling
+- **Accuracy**: Maintains or improves model performance
+- **Efficiency**: Lower carbon footprint and energy consumption
+
+## Package Structure
+```
+graft-pytorch/
+├── graft/
+│   ├── __init__.py          # Main package exports
+│   ├── trainer.py           # Training orchestration
+│   ├── genindices.py        # Sample selection algorithms
+│   ├── decompositions.py    # Feature decomposition
+│   ├── models/              # Supported architectures
+│   │   ├── resnet.py        # ResNet implementations  
+│   │   ├── efficientnet.py  # EfficientNet models
+│   │   └── BERT_model.py    # BERT for classification
+│   └── utils/               # Utility functions
+│       ├── loader.py        # Dataset loaders
+│       └── model_mapper.py  # Model selection
+├── tests/                   # Comprehensive test suite
+├── examples/                # Usage examples
+└── OIDC_SETUP.md           # Deployment configuration
+```
+
+## Contributing
+
+We welcome contributions! Please see our [contribution guidelines](CONTRIBUTING.md) for details.
+
+### Development Setup
+```bash
+# Clone the repository
+git clone https://github.com/ashishjv1/GRAFT.git
+cd GRAFT
+
+# Install in development mode
+pip install -e .[dev]
+
+# Run tests
+pytest tests/ -v
+
+# Run linting
+flake8 graft/ tests/
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use GRAFT in your research, please cite our paper:
+
+```bibtex
+@misc{jha2025graftgradientawarefastmaxvol,
+  title         = {GRAFT: Gradient-Aware Fast MaxVol Technique for Dynamic Data Sampling},
+  author        = {Ashish Jha and Anh Huy Phan and Razan Dibo and Valentin Leplat},
+  year          = {2025},
+  eprint        = {2508.13653},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.LG},
+  url           = {https://arxiv.org/abs/2508.13653}
+}
+```
+
+## Acknowledgments
+
+- Built using PyTorch
+- Inspired by MaxVol techniques for data sampling
+- Special thanks to the open-source community
+
+---
+
+**PyPI Package**: [graft-pytorch](https://pypi.org/project/graft-pytorch/)  
+**Paper**: [arXiv:2508.13653](https://arxiv.org/abs/2508.13653)  
+**Issues**: [GitHub Issues](https://github.com/ashishjv1/GRAFT/issues)  
+**Contact**: [Ashish Jha](mailto:Ashish.Jha@skoltech.ru)
+
+