Adel Chernyatov
4+ years exp
Python
Model Architecture & Training: 5/10
Data Pipeline & Feature Engineering: 5/10
Experimentation & Evaluation: 5/10
Active 18 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
A competent ML engineer at a senior (applied) level who builds end-to-end model training, inference and MLOps pipelines. The strongest proven skill is building billing-aware training and inference pipelines with thorough validation and tests - exemplified by the training_feasibility logic and the extensive training/inference test suite. There is limited evidence of measured efficiency work, distributed training architecture, or original research contributions in public code.
Technical skills
Python• Senior • 4y+
Python
FastAPI
Celery
SQLAlchemy
Alembic
Uvicorn
Pydantic
Databases
MinIO
PostgreSQL
AI/ML
Streamlit
Pandas
Scikit-learn
CatBoost
PyTorch Lightning
OpenCV
NumPy
Analytics
Matplotlib
Senior AI/ML Engineer
Confidence: High ML Engineer
A competent ML engineer at a senior (applied) level who builds end-to-end model training, inference and MLOps pipelines. The strongest proven skill is building billing-aware training and inference pipelines with thorough validation and tests - exemplified by the training_feasibility logic and the extensive training/inference test suite. There is limited evidence of measured efficiency work, distributed training architecture, or original research contributions in public code.
Model Architecture & Training
5/10
How well models are designed and trained
Applied model-building and training pipelines with sklearn and CatBoost, pipeline serialization and artifact handling; solid engineering-grade training runner but no novel architectures or custom optimizer/scheduler research.
Evidence
tabby_ml/app/services/model_training.py: ModelTrainingRunner._build_model/_build_feature_preprocessor/train_with_artifact
tabby_ml/tests/test_training_service.py: ModelTrainingRunnerTestCase (tests validating training behavior and metrics)
Unet_Chest_Segmentation/src/modules/model.py: UNet class implementation and training_step
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Clear data ingestion, validation and preprocessing pipelines for tabular and image data, with dataset analyzers and contour/dataframe creation utilities.
Evidence
tabby_ml/app/services/datasets.py: DatasetAnalyzer.load_dataframe and DatasetPersistenceService.create_dataset
tabby_ml/app/services/training_feasibility.py: _validate_dataframe and _build_probe_plan (data validation rules)
Unet_Chest_Segmentation/src/modules/process_contours.py: create_contour_numpy_df / save_contour / split_train_test_contour
Experimentation & Evaluation
5/10
How results are measured and tested
Reproducible experimentation and evaluation pipeline evidence - feasibility probes, explicit metrics and many unit tests that check metrics and behavior across edge cases.
Evidence
tabby_ml/app/services/training_feasibility.py: _probe_model/_model_score (baseline and model evaluation logic)
tabby_ml/tests/test_training_service.py: many tests validating feasibility probe behavior and training metrics
Unet_Chest_Segmentation/U-Net.ipynb: training/test loops using PyTorch Lightning and checkpoint usage
MLOps & Deployment
5/10
How models are shipped to production
MLOps and deployment engineering present - async workers, migrations, artifact storage, idempotent billing, API + frontend and tests covering worker/job lifecycle; pragmatic production concerns are addressed.
Evidence
tabby_ml/app/workers/celery_app.py and app/workers/tasks.py: Celery worker setup and task lifecycle handling
tabby_ml/alembic/versions/20260509_0001_baseline.py: full DB migration schema (including idempotency unique constraint on ledger_entries)
tabby_ml/app/services/model_artifacts.py and app/services/inference.py: artifact saving/loading and inference charging/idempotency
Computational Efficiency
2/10
How efficiently computing resources are used
Minimal explicit work on computational efficiency - GPU usage is present for vision notebooks and there are sensible inference limits, but no measured profiling, quantization or advanced optimizations.
Evidence
Unet_Chest_Segmentation/U-Net.ipynb and src/training.py: Trainer configured with accelerator='gpu' (GPU usage)
tabby_ml/app/services/inference.py: MAX_BATCH_INFERENCE_BYTES / MAX_BATCH_INFERENCE_ROWS limits
Research Depth & Innovation
2/10
Depth of research and new ideas
Some custom architectures (UNet) and engineering experiments (feasibility probe) but no evidence of novel research contributions or reproduced SOTA results.
Evidence
Unet_Chest_Segmentation/src/modules/model.py: UNet custom implementation
tabby_ml/app/services/training_feasibility.py: feasibility probe logic and metric definitions
Verified artifacts
Expertise
MLOps & Model Lifecycle• Senior
Computer Vision & Image Analysis• Middle
Industries
Data & Analytics• Middle
Health Care• Middle
Technologies
OpenCV
Pydantic
Deep Learning• mentioned only
Recommendations
- Develop production ML services that need reliable billing, idempotency and artifact management (training pipelines, inference endpoints, job orchestration).
- Build MLOps automation and monitoring around dataset ingestion, artifact versioning and worker orchestration (Celery + migrations + object storage integration).
- Prototype and productionize computer-vision models and data pipelines using PyTorch Lightning, including adding profiling and performance/efficiency work (quantization, batching, benchmarks).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium ML Practitioner
An ML-focused practitioner operating at a senior-level engineering maturity (conservative estimate: tier 5.0) who builds end-to-end model training, inference and billing-aware services. The strongest proven skill is production-oriented ML service design and testing, supported by TrainingFeasibilityService and extensive unit tests (see training_feasibility.py and tests/test_training_service.py). The public work lacks evidence of large-scale distributed systems design beyond Celery, formal causal/statistical analysis, and robust deployment/CI artifacts.
Statistical Rigor
6/10
Correct use of statistics
Thoughtful evaluation logic and baseline comparisons are implemented (no heavy inferential statistics or causal work, but clear checks for target suitability, class-cardinality and baseline vs learning gains).
Evidence
AdelChernyatov/tabby_ml/app/services/training_feasibility.py: _validate_dataframe, _probe_model, _baseline_score (checks for high-cardinality, almost-unique targets and baseline comparisons)
AdelChernyatov/tabby_ml/tests/test_training_service.py: tests asserting high-cardinality and almost-unique target rejection and feasibility probe behaviours
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Good data ingestion and cleaning patterns - dataset analyzer, file readers, type coercion and explicit missing / schema checks are present; some ad-hoc notebook ETL exists for sensor/merge work.
Evidence
AdelChernyatov/tabby_ml/app/services/datasets.py: DatasetAnalyzer/DatasetPersistenceService (load_dataframe, _normalize_column_names, _build_preview)
AdelChernyatov/tabby_ml/app/services/inference.py: _validate_frame and _coerce_feature_types (schema checks and numeric coercion)
AdelChernyatov/Merge_files/file_process.ipynb: sensor_processing, mobile_processing (data parsing and alignment logic)
Exploratory Analysis & Visualization
4/10
Exploring and visualizing data
UI and notebook visualizations exist (Streamlit dashboards, plotting in notebooks) but limited narrative EDA or systematic interpretation documented in-code; plots are primarily functional rather than analytic write-ups.
Predictive Modeling
6/10
Building models that predict
Predictive model pipelines, preprocessing (TFIDF for categorical), multiple model types and evaluation metrics are implemented with a baseline-first feasibility probe and thorough unit tests - good production-minded modelling but not research-level novel modelling.
Evidence
AdelChernyatov/tabby_ml/app/services/model_training.py: ModelTrainingRunner (_build_feature_preprocessor, _build_model, _regression_metrics, _classification_metrics)
AdelChernyatov/tabby_ml/tests/test_training_service.py: tests for training runner, artifact serialization, model-specific behavior and metric checks
Business Insight & Impact
6/10
Turning analysis into business value
Business logic is explicit - credit-based billing, idempotency, promo redemption and refunds are implemented and tested, showing concrete thought about cost, idempotency and user-facing effects.
Reproducibility & Notebook Hygiene
5/10
Clean, repeatable analysis
Reasonable reproducibility practices: many unit tests, alembic migrations, deterministic seeds passed into services; notebooks vary in hygiene but core services include tests and deterministic controls.
Expertise
Analytics• Senior
Industries
Data & Analytics• Middle
Health Care• Middle
Technologies
CatBoost
PyTorch Lightning
Scikit-learn
Matplotlib
Pandas
NumPy
Streamlit
Deep Learning• mentioned only
Recommendations
- Develop production-ready inference and model-registry features - implement a model registry + CI/CD for artifact promotion and automated exports using the existing ModelArtifactService and artifact tests as starting points.
- Harden data pipelines and validation - add automated data-contract checks (Great Expectations or Pandera) and integrate them into the DatasetAnalyzer and inference validation paths.
- Extend reproducibility and MLOps - add pinned environment files, Dockerfile/compose manifests and a reproducible training CI workflow for end-to-end testing of training tasks and artifact serialization.
- Prototype the medical imaging segmentation pipeline for production use - add data versioning, input validation and safe file-IO wrappers to the Unet data preprocessing notebooks and modules before running destructive operations.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
A backend engineer focused on building a billing-aware ML service, operating at a lower-bound senior level with solid backend and API engineering practices. The strongest proven skill is designing reliable inference and billing flows with idempotency and DB-level protections, evidenced by inference charging logic (app/services/inference.py), the ledger idempotency constraint in the Alembic migration, and focused unit tests validating refunds and idempotency (tests/test_training_service.py). The public code does not show advanced distributed-systems patterns like service-to-service contracts, sophisticated rate-limiting, or production-grade observability runbooks and measured performance optimizations.
API Design
6/10
How well APIs are designed
API design shows deliberate idempotency handling, clear error types and route-level dependency enforcement, but lacks explicit versioning strategy and advanced API policies (rate-limits, pagination).
Evidence
AdelChernyatov/tabby_ml/app/services/inference.py:_charge_inference implements idempotency-key-based charging
AdelChernyatov/tabby_ml/tests/test_training_service.py:test_single_inference_charges_once_per_idempotency_key validates idempotency behavior
AdelChernyatov/tabby_ml/app/api/v1/training.py:routes use get_current_user dependency enforced in tests
Data Layer & Database
6/10
Working with databases
Data-layer shows schema migrations, DB constraints for correctness and idempotency, repositories wrapping SQLAlchemy queries and patterns for SELECT FOR UPDATE; good schema design and integrity checks are present.
Evidence
AdelChernyatov/tabby_ml/alembic/versions/20260509_0001_baseline.py:uq_ledger_entries_idempotency unique constraint and many DB-level checks
AdelChernyatov/tabby_ml/app/repositories/wallets.py:get_by_user_id_for_update (repository-level for-update support)
AdelChernyatov/tabby_ml/app/models/*.py:declarative models across domain (datasets, wallets, training_jobs)
Scalability & Performance
5/10
Handling load and speed
Scalability choices include async worker (Celery), batch size & file-size limits, and separation of object storage; lacks documented caching, rate-limiting or measured perf tuning artifacts.
Evidence
AdelChernyatov/tabby_ml/app/workers/celery_app.py:Celery worker wiring and lifecycle hooks
AdelChernyatov/tabby_ml/app/services/inference.py:MAX_BATCH_INFERENCE_BYTES and MAX_BATCH_INFERENCE_ROWS enforce limits
AdelChernyatov/tabby_ml/pyproject.toml:dependencies include celery, redis (via celery[redis]), and minio for async and object storage
System Architecture
5/10
Overall system structure
Clear modular structure (api, services, repositories, models, workers) and separation of concerns; good surface-area decomposition for a single-service ML platform but no multi-service contract examples or complex distributed trade-offs.
Evidence
AdelChernyatov/tabby_ml/app/api/v1/__init__.py:versioned v1 API router composition
AdelChernyatov/tabby_ml/app/services/*:well-separated domain services (training, inference, billing, storage)
AdelChernyatov/tabby_ml/app/core/logging.py + app/api/middleware.py:separation of cross-cutting concerns (request id, logging)
Security & Auth
5/10
Protecting data and access
Authentication and token handling are implemented, input validation via Pydantic is present, and DB constraints protect integrity; advanced security hardening (rate-limits, secrets rotation, dependency audit) are not visible in code artifacts provided.
Evidence
AdelChernyatov/tabby_ml/app/core/security.py:create_access_token,decode_access_token,password hashing utilities
AdelChernyatov/tabby_ml/app/api/deps.py:get_current_user dependency wiring for auth
AdelChernyatov/tabby_ml/alembic/versions/20260509_0001_baseline.py:DB constraints (e.g. wallet balance non-negative, ledger checks)
Reliability & Observability
6/10
Stability and monitoring
Good observability and reliability practices are present - structured logging with request ids, tests for failure and refund flows, and worker lifecycle hooks; retry/backoff and circuit-breaker patterns are not clearly visible.
Evidence
AdelChernyatov/tabby_ml/app/core/logging.py:JsonFormatter, request_id context management and configure_logging
AdelChernyatov/tabby_ml/tests/test_training_service.py:test_failed_training_refunds_training_charge verifies refund-on-failure behavior
AdelChernyatov/tabby_ml/app/workers/celery_app.py:worker signals (startup/shutdown/task events) for lifecycle observability
Expertise
Python• Middle
Microservices & API Architecture• Middle
Messaging & Real-time• Middle
Databases & Vector Storage• Middle
Industries
Data & Analytics• Middle
Technologies
Python• Senior • 4y+
PostgreSQL
SQLAlchemy
MinIO
FastAPI
Celery
Uvicorn
Alembic
Recommendations
- Develop inference-serving and billing endpoints and orchestrate Celery-based training workflows (augmenting with retries/backoff and operational metrics).
- Extend data-layer work - implement transactional wallet operations with explicit isolation comments and migration history for evolving schemas.
- Own API surface for ML features - add formal API versioning, pagination, rate-limiting and documented idempotency semantics.
- Implement and document observability playbooks - add metrics, traces (OpenTelemetry), and measured performance tests for heavy paths (batch inference, artifact download).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: