Following this instruction :
1. Strictly adhere to PEP-8 standards, ensuring code is clean, well-structured, and follows Python's style guide for readability.
2. Use appropriate modules like `typing` for type hints, ensuring code clarity, maintainability, and leveraging Python's standard libraries effectively.
3. Focus on time, space, robustness, scalability; write optimized, efficient code that can handle large datasets and scale seamlessly.
4. Implement comprehensive error handling, catching exceptions gracefully, providing meaningful error messages, and ensuring code robustness under unexpected conditions.
5. Ensure the developer agent writes advanced, maintainable Python code, balancing performance and readability while adhering to best practices.

TASK : we have generalised , robustness , scaleable  pipeline image classification task , USER input name or path of dataset



Details of module (which is know about datasets ) 
Here's a detailed explanation of key features and modules in the datasets library:

1. Dataset Loading and Creation:
```python
from datasets import load_dataset, Dataset

# Load existing dataset
dataset = load_dataset('dataset_name')

# Create custom dataset
dataset = Dataset.from_dict(dictionary)
dataset = Dataset.from_pandas(dataframe)
```

2. Dataset Structure:
- Dataset: Single dataset object
- DatasetDict: Multiple datasets (train/test/validation splits)
- Features: Column specifications and types
```python
dataset.features  # View features
dataset.column_names  # List column names
dataset.shape  # Get dimensions
```

3. Feature Types:
```python
from datasets import Features, Value, ClassLabel, Sequence

features = Features({
    'text': Value('string'),
    'label': ClassLabel(names=['positive', 'negative']),
    'tokens': Sequence(Value('string')),
    'age': Value('int32'),
    'score': Value('float')
})
```

4. Data Access and Iteration:
```python
# Access methods
dataset[0]  # Single example
dataset['column_name']  # Single column
dataset[0:10]  # Slicing

# Iteration
for example in dataset:
    print(example)
```

5. Data Transformation:
```python
# Map function
dataset = dataset.map(function)

# Filter data
dataset = dataset.filter(lambda x: condition)

# Select/remove columns
dataset = dataset.select_columns(['col1', 'col2'])
dataset = dataset.remove_columns(['col1'])
```

6. Shuffling and Sampling:
```python
# Shuffle dataset
shuffled_dataset = dataset.shuffle(seed=42)

# Sample subset
sample = dataset.select(range(100))
```

7. Format Conversion:
```python
# Convert to different formats
pandas_df = dataset.to_pandas()
dict_data = dataset.to_dict()
numpy_array = dataset.to_numpy()
```

8. Saving and Loading:
```python
# Save dataset
dataset.save_to_disk('path/to/save')

# Load saved dataset
from datasets import load_from_disk
dataset = load_from_disk('path/to/save')
```

9. Concatenation and Splitting:
```python
# Concatenate datasets
from datasets import concatenate_datasets
merged = concatenate_datasets([dataset1, dataset2])

# Train-test split
split = dataset.train_test_split(test_size=0.2)
```

10. Caching:
```python
# Cache management
dataset.cleanup_cache_files()
dataset.set_cache_dir('path/to/cache')
```

11. Dataset Information:
```python
# View dataset info
dataset.info.features
dataset.info.description
dataset.info.citation
```

12. Custom Loading:
```python
# Load from custom files
dataset = load_dataset('csv', data_files='path/to/file.csv')
dataset = load_dataset('json', data_files='path/to/file.json')
```

13. Data Validation:
```python
# Verify data types
dataset.validate()

# Check for missing values
dataset.cleanup_cache_files()
```

14. Processing Functions:
```python
# Batch processing
dataset = dataset.map(function, batched=True)

# Parallel processing
dataset = dataset.map(function, num_proc=4)
```

15. Memory Management:
```python
# Memory mapping
dataset.set_format('memory')
dataset.reset_format()
```

These modules and features allow you to:
- Load and manipulate datasets efficiently
- Transform and preprocess data
- Handle various data formats
- Manage memory effectively
- Split and combine datasets
- Cache operations for better performance
- Validate and clean data
- Process data in parallel
- Convert between different formats
- Save and load processed datasets

The library is particularly useful for:
- Machine Learning tasks
- Natural Language Processing
- Data preprocessing
- Dataset management
- Research and experimentation