Implementing AI-Powered Image Recognition in Python

# Title: Implementing Image Recognition in Python
# Description: Guidelines for developing image recognition applications using Python, focusing on deep learning models and accuracy.
# Category: Python Cursor Rules

## General Guidelines
- Use Python 3.9 or later for all development to ensure compatibility with the latest features and security updates.
- Follow PEP 8 for code style to maintain readability and consistency.
- Use type hints to improve code clarity and facilitate static analysis.

## Project Structure
- Organize the project into the following directories:
  - `data/`: For storing datasets.
  - `models/`: For saving trained models.
  - `notebooks/`: For Jupyter notebooks used in experimentation.
  - `src/`: For source code, including modules for data processing, model definition, training, and evaluation.
  - `tests/`: For unit and integration tests.

## Dependencies
- Use a virtual environment (e.g., `venv` or `conda`) to manage project dependencies.
- Specify all dependencies in a `requirements.txt` file or `pyproject.toml` for reproducibility.
- Regularly update dependencies to incorporate the latest improvements and security patches.

## Data Handling
- Implement data loading and preprocessing pipelines using libraries like `pandas` and `numpy`.
- Ensure data augmentation techniques are applied consistently during training to improve model generalization.
- Handle data splits (training, validation, testing) appropriately to prevent data leakage.

## Model Development
- Use deep learning frameworks such as TensorFlow or PyTorch for model development.
- Define models in a modular fashion to facilitate experimentation and reuse.
- Implement appropriate loss functions and evaluation metrics for image recognition tasks.

## Training and Evaluation
- Use GPU acceleration when available to speed up training processes.
- Monitor training performance using tools like TensorBoard or Weights & Biases.
- Implement early stopping and learning rate scheduling to optimize training.
- Evaluate models on a separate test set to assess generalization performance.

## Code Quality and Testing
- Write unit tests for all functions and classes to ensure code reliability.
- Use testing frameworks like `pytest` to automate testing processes.
- Maintain high test coverage to catch potential issues early.

## Documentation
- Provide docstrings for all functions, classes, and modules to explain their purpose and usage.
- Create a `README.md` file with instructions on setting up the environment, running the code, and understanding the project structure.
- Document any assumptions, limitations, and potential improvements for the project.

## Version Control
- Use Git for version control to track changes and collaborate effectively.
- Commit changes with clear and descriptive messages.
- Use branching strategies (e.g., feature branches, pull requests) to manage development workflows.

## Performance Optimization
- Profile code to identify bottlenecks and optimize performance-critical sections.
- Use efficient data structures and algorithms to improve processing speed.
- Implement batch processing to handle large datasets effectively.

## Security and Compliance
- Ensure that all data handling complies with relevant data protection regulations.
- Avoid hardcoding sensitive information; use environment variables or configuration files instead.
- Regularly review code for potential security vulnerabilities.

## Deployment
- Containerize the application using Docker to ensure consistency across different environments.
- Use continuous integration and deployment (CI/CD) pipelines to automate testing and deployment processes.
- Monitor deployed models for performance degradation and retrain as necessary.