Arseny Konevets
AI Engineer
4+ years exp
3+ projects
Python
Model Architecture & Training: 6/10
Research Depth & Innovation: 6/10
Experimentation & Evaluation: 5/10
Active 1 day ago
+7 (924) 2398990 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
I am an AI/ML specialist with a stronger focus on research and experimentation than on production engineering. My main interests include NLP, LLMs, RAG and agentic systems, efficient neural architectures, and simultaneous machine translation. My research experience includes developing and evaluating Transformer-, Mamba-2-, and hybrid architectures for low-latency translation, while my professional experience includes building an AI agent and applied LLM-based solutions. I particularly enjoy formulating hypotheses, designing experiments, analyzing model behavior, and turning research ideas into working prototypes.
Technical skills
Python• Middle • 4y+ • 3 projects
Databases
PostgreSQL
RabbitMQ
Weaviate
MinIO
AI/ML
Transformers
MLFlow
Pandas
NumPy
Scikit-learn
AI/ML• 3y+ • 2 projects
LangChain• 3y+
NLP• 2 projects
ChatGPT
LLM
PyTorch
Fine-tuning
LangGraph
Embeddings
DevOps
AWS
Git• 3y+
Docker
Analytics
Matplotlib
Seaborn
Timeline
Far Eastern Federal University
Master's Degree •
Artificial Intelligence and Big Data
AI Engineer
•
Middle
STAKEME.pro
•
Contractor
I worked on an AI agent for blockchain technical support, built around a production RAG system and self-hosted LLMs. I contributed across the full development cycle, including collecting and processing data from technical documentation, Discord, and Telegram, building the retrieval pipeline, integrating blockchain explorer APIs through tool calling and LangChain/LangGraph, and monitoring the system with Langfuse, Loki, and Grafana.
Python
NLP
LLM
vLLM
LangGraph
LangChain
Langfuse
Grafana
Prometheus
Loki
Docker
Transformers
PostgreSQL
Qdrant
FastAPI
AI Agents
RAG
Far Eastern Federal University
Bachelor's Degree •
Computer Science
Senior AI/ML Engineer
Confidence: Medium Research
A research-focused ML engineer who builds custom sequence-to-sequence and simultaneous translation systems. The strongest proven skill is custom model and training engineering demonstrated by model_classes (transformer.py, mamba.py, hybrid.py) and the distillation training pipeline (training/losses.py and distillation.ipynb). Public code does not show production-grade deployment automation, broad test coverage or formal CI/CD for models.
Model Architecture & Training
6/10
How well models are designed and trained
Clear custom model architecture and training engineering: multiple custom model classes (transformer, Mamba2, hybrid), training loops and distillation logic are implemented.
Evidence
LinearSimultMT/model_classes/transformer.py: TransformerMT class with encode/decode/forward_waitk and PositionalEncoding
LinearSimultMT/model_classes/mamba.py: Mamba2MT class with generate_incremental_waitk, allocate_inference_cache and step_token implementations
LinearSimultMT/training/losses.py: simulmt_distillation_loss and masked_* loss functions
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Dataset and preprocessing code exists but is mostly notebook-driven; there is some structured dataset code for HDF5-backed translation datasets.
Evidence
LinearSimultMT/training/dataset.py: TranslationDataset with lazy HDF5 opening and __getitem__
LinearSimultMT/dataset_analysis.ipynb: split_multi_hdf5 and valid_char_percent utilities
Experimentation & Evaluation
5/10
How results are measured and tested
Experimentation and evaluation pipelines are present including MLflow logging and custom evaluators and scorers for quality and latency.
Evidence
LinearSimultMT/training/helpers.py: log_configs_to_mlflow and save_and_log_checkpoint functions
LinearSimultMT/evaluation/metrics.py: MTQualityScorer and WaitKLatencyScorer
LinearSimultMT/evaluation/evaluator.py: SimulMTEvaluator evaluate orchestration using sacrebleu metrics
MLOps & Deployment
4/10
How models are shipped to production
Basic MLOps/serving and model lifecycle hooks exist (checkpointing, upload/download helpers, streaming inference generator) but full production serving/instrumentation is limited.
Evidence
LinearSimultMT/training/helpers.py: save_and_log_checkpoint, load_training_checkpoint
LinearSimultMT/extra/upload.py: upload helper for artifacts
LinearSimultMT/extra/download.py: download helper
Computational Efficiency
5/10
How efficiently computing resources are used
Efficiency-conscious code for online/streaming inference and cache allocation is implemented; GPU memory logging and parameter counting are present.
Evidence
LinearSimultMT/model_classes/mamba.py: allocate_inference_cache and step_token to support efficient incremental generation
LinearSimultMT/distillation.ipynb: log_gpu_memory_to_mlflow and save_and_log_checkpoint utilities
LinearSimultMT/training/helpers.py: count_parameters and log_gpu_memory_to_mlflow
Research Depth & Innovation
6/10
Depth of research and new ideas
Research-level depth is evidenced by implementing hybrid Mamba2/Transformer architectures, distillation losses and latency-aware evaluation for simultaneous MT.
Evidence
LinearSimultMT/model_classes/hybrid.py: HybridMamba2MT with cross-decoder layers and stream_generator
LinearSimultMT/distillation.ipynb: simulmt_distillation_loss_flexible, generate_whole_sequence_teacher and related distillation/training utilities
LinearSimultMT/evaluation/metrics.py: WaitKLatencyScorer showing custom latency-aware evaluation
Expertise
LLM• Middle
Industries
Commerce• Middle
Media & Entertainment• Middle
Technologies
MLFlow
Recommendations
- Lead R&D projects building real-time or low-latency sequence-to-sequence models (simultaneous MT, streaming ASR/MT) focusing on architecture and distillation experiments.
- Develop research-to-prod model inference components (efficient incremental generation, cache allocation, and latency-aware serving) leveraging the existing streaming generators and cache code.
- Own experiment pipelines and evaluation suites (MLflow-driven experiments, latency/quality scorers) to turn notebooks and scripts into reproducible experiment modules.
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 practitioner focused on applied multimodal classification at a middle level, demonstrated by a single end-to-end training notebook that implements dataset handling and a PyTorch-based model. The strongest proven skill is building and training predictive models in a notebook environment, supported by the AdDataset and AdClassifier classes and the training loop in farpost.ipynb. Not evidenced are productionization, automated pipelines, test coverage, rigorous statistical analysis and reproducible experiment infrastructure.
Statistical Rigor
2/10
Correct use of statistics
Minimal statistical rigor - notebook contains metric reporting but no explicit assumption checks, significance testing, uncertainty quantification or causal analysis.
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Evidence of custom dataset handling and basic preprocessing (dataset class, label encoding, train/test split) but limited evidence of robust provenance, leakage checks or extensive cleaning pipelines.
Exploratory Analysis & Visualization
3/10
Exploring and visualizing data
Exploratory work is present (matplotlib / seaborn imports and likely plots) but there is little evidence of narrative-driven interpretation or question-driven storytelling in the artifacts analyzed.
Predictive Modeling
5/10
Building models that predict
Solid predictive modeling practice for an individual notebook: custom PyTorch model wrapper, training loop, use of pretrained embeddings (sentence-transformers) and torchmetrics; however there is limited evidence of robust cross-validation schemes, time-aware splits, model calibration, or extensive error analysis.
Business Insight & Impact
2/10
Turning analysis into business value
Little evidence of explicit business-metric linkage, cost-of-error reasoning, or operational recommendations in the code artifacts; problem is clearly applied but business impact tuning is not shown.
Reproducibility & Notebook Hygiene
2/10
Clean, repeatable analysis
A single monolithic notebook with model and data code - reproducibility practices (pinned env, explicit seeds, CI, data versioning) are not evidenced in the human-authored artifact analyzed.
Expertise
Analytics• Middle
Industries
Commerce• Middle
Technologies
Scikit-learn
Seaborn
Matplotlib
Transformers
Pandas
NumPy
Recommendations
- Develop and extract the training and data-loading code into modular scripts or a small package so it can be unit-tested and reused (e.g., dataset.py, model.py, train.py).
- Add reproducibility and MLOps elements: set seeds, log experiments (MLFlow/Weighs & Biases), and provide a pinned environment or a lightweight Dockerfile/DVC for dataset versioning.
- Improve statistical rigor and evaluation: add uncertainty quantification, bootstrapped confidence intervals for metrics, clearer error analysis and confusion-matrix-driven business tradeoff decisions.
- Create automated training and inference pipelines (Airflow/Prefect) or lightweight CLI wrappers so models can be served and retrained reliably.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Backend Developer
Confidence: Low API Engineer
A backend-focused developer at an early junior level who produces multi-package Python projects (API, bot, db manager, embedder) but the public artifacts contain configuration rather than original application code. The strongest proven skill is building small async/HTTP API and integration scaffolding - evidenced by FastAPI/Uvicorn and async/queue/vector dependencies in the api, bot and embedder pyproject/requirements files. There is little to no visible human-authored application code, no migration history, no implemented resilience or observability patterns, and no production-grade security/auth lifecycle demonstrated in the public files.
API Design
2/10
How well APIs are designed
FastAPI/Uvicorn present indicating API work but there is no visible API design (versioning, idempotency, error contracts) or hand-authored route logic to evaluate.
Data Layer & Database
2/10
Working with databases
ORM and Postgres client are declared (SQLAlchemy, psycopg2) showing basic backend data-layer choice but there is no migration history, tuned SQL, or transaction/isolation handling visible.
Scalability & Performance
2/10
Handling load and speed
Async libraries, S3/MinIO client, message client and a vector client appear in dependencies (suggesting attention to async and decoupling) but there are no concrete caching, measured optimizations, or cache-invalidation strategies in the provided files.
System Architecture
2/10
Overall system structure
Project is split into distinct packages (api, bot, db_manager, embedder) indicating a deliberate service decomposition, but inter-service contracts, graceful degradation or config/secret orchestration code are not present to show mature architecture decisions.
Security & Auth
2/10
Protecting data and access
Dependencies show basic security tooling (python-dotenv, cryptography, validators) and an awareness of secrets, but there is no visible auth lifecycle, token handling, input-validation code or dependency-audit evidence in author-written code.
Reliability & Observability
1/10
Stability and monitoring
Async and queue-related libraries are present which are the building blocks for reliability, but there is no visible implementation of retries/backoff, circuit breakers, structured logging, metrics or graceful shutdown patterns in the files provided.
Expertise
Python• Intern
Microservices & API Architecture• Intern
Messaging & Real-time• Intern
Databases & Vector Storage• Intern
Technologies
PostgreSQL
Weaviate
RabbitMQ
MinIO
AWS
Recommendations
- Assign to develop small-to-medium FastAPI services and related HTTP integrations (endpoints, request validation, Pydantic models).
- Work on asynchronous integrations and message-driven features such as Telegram bot handlers and pika-based queue consumers, where existing dependency choices align with the work.
- Implement and own DB-backed CRUD and data-access layers using SQLAlchemy with explicit migrations and transaction handling to strengthen data-layer evidence.
- Prototype vector-search integration flows (Weaviate) and S3-compatible storage workflows (MinIO/aioboto3), focusing on end-to-end examples and operational concerns (auth, retries, metrics).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: