Zhenya Samchuk
AI Engineer
4+ years exp
C++
C
Python
SQL
Active 14 days ago
+375 (33) 3207004 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A developer who builds original language and compiler tooling and multiple Python applications, assessed at a lower-mid senior level. The strongest proven skill is implementing a custom language front-end and LLVM IR emission (concrete artifacts: ProgramCompiler, FunctionCompiler, ExpressionCompiler and usage of llvmlite in src/compilers). There is limited or no public evidence of CI/CD, IaC, cloud architecture, orchestration, observability, or formal SRE practices in the human-authored code.
Technical skills
C++
C
Python• Senior • 4y+
SQL• Junior
C++
LLVM
PyTorch C++
TensorFlow C++
Python
Django
FastAPI
Flask
Beautiful Soup
Requests
Databases
MS SQL
Qdrant
RabbitMQ
AI/ML
Computer Vision
MLFlow
NumPy
OpenCV
Pandas
TensorFlow
Time Series Forecasting
Deep Learning
Torchvision
scikit-image
Scikit-learn
Transformers
TF-Keras
ONNX• 3y+
Quantization• 3y+
CatBoost
LangChain
PyTorch
LLM
RAG
NLP
DevOps
Rest API
CI/CD• 3y+
Docker• 3y+
Git• 3y+
GitHub Actions• 3y+
Analytics
Matplotlib
Power BI
Seaborn
Timeline
Python AI Engineer
•
Middle
STA Logistics
•
Full-Time
Developed a corporate-chat Python bot to evaluate employee audio responses against pre-defined questions using AI models. Integrated task processing through RabbitMQ queues and stored evaluation outputs, metadata, and logs in MongoDB. Built an audio pipeline bot that transcribes meetings (ASR) and generates summaries using AI/LLM providers, with sequential RabbitMQ processing stages and structured storage. Implemented a RAG system in the corporate messenger using document chunking, Qdrant in a local Docker container, and LLM-driven answers, plus an Outlook bot that extracts criteria from Excel files and generates documents with LLM processing.
RabbitMQ
Docker
Qdrant
LLM
RAG
Machine Learning Engineer
•
Middle
Belgazprombank
•
Full-Time
Analyzed bank data to create, test, and implement machine learning models and to prepare datasets for training. Built Power BI dashboards and automated periodic refresh flows using Prefect, including end-to-end steps from database extraction and transformations to prediction export. Developed outflow trend modeling using gradient-boosting approaches and validated multiple model types, then added post-processing to match dashboard format and continuous model-quality checks. Implemented transliteration for customer surnames and a call center analytics pipeline with ASR/VAD/diarization, followed by LLM-based dialogue analysis using LangChain.
CatBoost
PyTorch
LangChain
БГУИР (бывш. МРТИ)
Bachelor's Degree •
Искусственный Интеллект
Machine Learning Engineer
•
Middle
Taqtile
•
Full-Time
Built and deployed computer-vision systems for counting objects in a warehouse and for evaluating employee activity using tracking and object detection. Developed an LLM-based chatbot using the Llama-7B model and additional specialized QA training data from the customer. Implemented speech generation by combining local recognized-text correction with a remote Google service via a browser extension. Containerized algorithms with Docker and automated build/push via GitHub-based CI/CD; optimized models using ONNX conversion and quantization.
Dockersince 2023
CI/CD
GitHub Actions
ONNX
Quantization
Senior DevOps Engineer
Confidence: Medium Generalist
A developer who builds original language and compiler tooling and multiple Python applications, assessed at a lower-mid senior level. The strongest proven skill is implementing a custom language front-end and LLVM IR emission (concrete artifacts: ProgramCompiler, FunctionCompiler, ExpressionCompiler and usage of llvmlite in src/compilers). There is limited or no public evidence of CI/CD, IaC, cloud architecture, orchestration, observability, or formal SRE practices in the human-authored code.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
Managing servers with code
Not evidenced in public code
Containerization & Orchestration
Working with containers
Not evidenced in public code
Observability & Monitoring
Watching system health
Not evidenced in public code
Reliability & Incident Response
Keeping systems up
Not evidenced in public code
Cloud & Cost Optimization
Smart use of the cloud
Not evidenced in public code
Industries
Real Estate• Middle
Technologies
FastAPI
Beautiful Soup
Requests
Recommendations
- Lead development of compiler/tooling or language-front-end features (IR generation, semantic analysis, optimization passes) using the existing ProgramCompiler and FunctionCompiler modules.
- Implement developer-facing language tools: REPLs, CLI tooling, tests and packaging for the language runtime to increase adoption and reliability.
- Extend the real-estate RAG project into a small ML-backed service (FastAPI endpoints, robust scraping pipelines, and vector store ingestion) while adding tests and CI.
- Collaborate on backend Python services that require custom parsing, transformation, or embedding pipelines where strong parsing/semantics skills are needed.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: Medium ML Engineer
A hands-on ML engineer (middle level) who independently implements standard semantic-segmentation architectures and common losses in PyTorch and runs end-to-end training in notebooks. The strongest proven skill is applied segmentation model engineering - concrete evidence is the full SegNet encoder-decoder implementation, custom training loop, IoU metric and multiple loss implementations in ML/DL-school/Semantic_segmentation.ipynb. The work lacks production MLOps, checkpointing/serving, systematic experiment tracking, and advanced efficiency or research contributions in the public human-authored files.
Model Architecture & Training
3/10
How well models are designed and trained
Solid, correct implementation of standard segmentation architectures (SegNet/UNet) and multiple loss functions; training loop is hand-rolled in notebook but follows standard patterns rather than demonstrating novel architecture design or advanced optimization.
Evidence
ML/DL-school/Semantic_segmentation.ipynb: class SegNet definition and forward implementation (encoder/decoder, MaxPool/Unpool usage)
ML/DL-school/Semantic_segmentation.ipynb: train(...) function - custom training loop with optimizer.step(), loss.backward(), device placement and plotting
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Basic dataset loading and preprocessing present (skimage resize, torch DataLoader). No advanced augmentation, imbalance handling, or pipeline engineering is shown.
Evidence
ML/DL-school/Semantic_segmentation.ipynb: dataset loading using skimage.io.imread and skimage.transform.resize to 256x256
ML/DL-school/Semantic_segmentation.ipynb: DataLoader construction (DataLoader(list(zip(...))) )
Experimentation & Evaluation
2/10
How results are measured and tested
Contains simple, useful experimentation primitives - IoU metric, training/validation loops and plotting of loss/IOU. Missing experiment tracking, reproducible configs, hyperparameter sweeps, or held-out experiment management.
Evidence
ML/DL-school/Semantic_segmentation.ipynb: iou_pytorch(outputs, labels) function and thresholding logic
ML/DL-school/Semantic_segmentation.ipynb: score_model(...) and metric plotting in train(...)
MLOps & Deployment
1/10
How models are shipped to production
Almost no MLOps; training loops run in notebook, no checkpointing, model versioning, CI/CD, or serving code is present in the analyzed human-authored files.
Evidence
ML/DL-school/Semantic_segmentation.ipynb: train(...) uses torch.cuda.memory.empty_cache() but no torch.save()/checkpoint or model export
ML/DL-school/Semantic_segmentation.ipynb: inference functions are notebook-scoped (score_model) without serialization/serving code
Computational Efficiency
1/10
How efficiently computing resources are used
Minimal efficiency engineering - device placement and empty_cache calls are present, but no profiling, mixed precision, quantization, or distributed training evidence in the human-authored files.
Evidence
ML/DL-school/Semantic_segmentation.ipynb: training code uses model.to(device) and torch.cuda.memory.empty_cache()
Research Depth & Innovation
1/10
Depth of research and new ideas
Implements standard losses (BCE, Dice, Focal, combo) and references papers, but no novel algorithms or reproduced SOTA research are present.
Evidence
ML/DL-school/Semantic_segmentation.ipynb: implementations of dice_loss, focal_loss, dice/BCE combo_loss and references to SegNet paper
ML/DL-school/Semantic_segmentation.ipynb: notes and pointers to boundary/Tversky/loss literature (discussion sections)
Verified artifacts
Expertise
Computer Vision & Image Analysis• Middle
Technologies
SQL• Junior
C++
Rest API
LangChain
CatBoost
Flask
Qdrant
RabbitMQ
MLFlow
GitHub Actions• 3y+
Quantization• 3y+
Computer Vision
NLP
ONNX• 3y+
MS SQL
CI/CD• 3y+
TensorFlow
Django
Git• 3y+
PyTorch
Docker• 3y+
LLM
RAG
TensorFlow C++
PyTorch C++
LLVM
Torchvision
Time Series Forecasting
Pandas• mentioned only
Recommendations
- Use to develop and prototype semantic-segmentation models and loss-ablation experiments (medical imaging, dataset research, model comparisons).
- Implement model checkpointing, reproducible experiment configs and lightweight experiment tracking (W&B/MLflow) to move notebooks toward production-ready training pipelines.
- Harden training loops: add unit/integration tests for loss/metric implementations and add model serialization and inference scripts for deployment.
- If targeting production, focus on efficiency work (mixed precision, dataset pipelines, batching, profiling) and add CI/CD for reproducible builds and model validation.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Data Scientist
Confidence: Medium ML Practitioner
A practical hands-on machine-learning practitioner at a competent middle level who writes working notebooks and implementing models from scratch. The strongest proven skill is applied deep-learning for computer-vision segmentation, concretely shown in ML/DL-school/Semantic_segmentation.ipynb (SegNet/IoU training loop) and ML/U-Net/U-Net.py. The public work lacks production-grade reproducibility, rigorous statistical validation, and MLOps/pipeline engineering for deployment.
Statistical Rigor
2/10
Correct use of statistics
Basic metric implementation (IoU) and loss work are present, but there is almost no statistical rigor - no uncertainty quantification, no hypothesis tests, no calibration, and little treatment of negative results.
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Solid, practical data wrangling for CV tasks - dataset loading, resizing, train/val/test splits and DataLoader pipelines are implemented, but provenance, heavy cleaning pipelines and leakage checks are not systematic.
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Notebooks include useful visualizations and plots; these are primarily template/diagnostic plots and some visual inspection of predictions rather than polished question-driven EDA or written storytelling tied to decisions.
Predictive Modeling
5/10
Building models that predict
Clear hands-on model work: custom SegNet/UNet implementations, multiple loss functions (BCE, Dice, Focal, combo) and training loops are implemented end-to-end. Good applied modeling discipline, but missing robust CV schemes, calibration, more advanced error analysis and automated experiments.
Business Insight & Impact
1/10
Turning analysis into business value
Very little business framing or cost-sensitive reasoning - the notebooks focus on model-building and homework-style reports, not on error-costs, decision metrics, or actionable product impact.
Reproducibility & Notebook Hygiene
2/10
Clean, repeatable analysis
Notebooks are reasonably structured and include a requirements.txt in one project and some seed-setting, but reproducibility is informal (many interactive notebooks, no pinned env for all projects, no data/versioning, limited pipelineization).
Expertise
Analytics• Middle
Industries
Health Care• Middle
Technologies
Deep Learning
Python• Senior • 4y+
OpenCV
Power BI
Scikit-learn
Seaborn
Matplotlib
Transformers
Pandas
NumPy
TF-Keras
scikit-image
Recommendations
- Use them to prototype and iterate on computer-vision models (segmentation/medical imaging) - they can implement architectures and losses and run experiments.
- Assign them to build and evaluate research-style experiments (custom losses, ablations, visual error analysis) where quick iteration and model coding matter.
- Pair them with a senior engineer to harden training into reproducible pipelines - add CI, fixed envs, data versioning (DVC), and robust CV and calibration.
- Have them convert notebooks into reusable modules and production-friendly training pipelines (Airflow/MLflow/continuous training) under guidance.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: