Evgenii Borisenko
ML Engineer
Python
Model Architecture & Training: 4/10
Data Pipeline & Feature Engineering: 4/10
MLOps & Deployment: 4/10
Active 16 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend engineer (Python) at a senior-contributing level (tier 4.5) focused on building async APIs and LLM/FAISS-backed ML pipelines. The strongest proven skill is implementing a FAISS-backed vector-search microservice and orchestration with FastAPI and autosave/backup logic (PredictOutcomes/faiss_manager/faiss_service.py). There is limited public evidence of production hardening such as CI/CD, structured observability (tracing/metrics), formal DB migrations, or secure secret management.
Technical skills
Python• Senior
Python
Aiohttp
Asyncio
FastAPI
Uvicorn
Pydantic
Databases
FAISS
SQLite
AI/ML
DeepSeek
LangChain
LLM
RAG
TensorFlow
OpenAI SDK
TF-Keras
Scikit-learn
Pandas
NumPy
Keras
DevOps
Docker
Rest API
Timeline
Senior AI/ML Engineer
Confidence: Medium LLM Engineer
LLM engineer with senior-level practical experience building retrieval-augmented and self-learning sports prediction pipelines using FAISS and LLM orchestration. The strongest proven skill is engineering production-capable RAG components and orchestration, evidenced by the FAISS FastAPI service and the Predictor/Trainer/Tagger orchestration (faiss_service.py and PredictOutcomes/core/*). The codebase shows limited formal experiment tracking, few unit tests, and uneven code polish which reduces confidence for high-assurance production delivery without refactoring and test coverage.
Model Architecture & Training
4/10
How well models are designed and trained
Practical model-building with custom losses, metrics and end-to-end training loops in TensorFlow/Keras.
Evidence
NeuronetPredictor/core/model.py: Model_sport.learning - custom training loop, threshold search and metrics
NeuronetPredictor/autoencoder/ae_model.py: Autoencoder, Encoder, Decoder and create_and_train_autoencoder
NeuronetPredictor/core/custom/custom_focal_loss.py: focal_precision_loss
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Complete preprocessing and feature engineering pipelines including imputation, scaling, indicator features and class balancing (SMOTE/oversample/undersample).
Evidence
NeuronetPredictor/core_new/prepocessing.py: Preproccessing.learning and _normalization, indicators_setup
NeuronetPredictor/autoencoder/get_data.py: Betting.data_syntetic, clip_outliers_median, fit_normalization
NeuronetPredictor/core/get_data.py: Df_getter signatures for dataset construction
Experimentation & Evaluation
3/10
How results are measured and tested
Basic experimentation and evaluation with training history plotting, confusion matrices and validation logic but no experiment tracking system shown.
Evidence
NeuronetPredictor/autoencoder/ae_model.py: plot_training_history and training history usage
NeuronetPredictor/core/model.py: validation threshold search using precision_recall_curve and confusion matrix
PredictOutcomes/core/trainer.py: validate_prompts implements a validation flow over test_matches
MLOps & Deployment
4/10
How models are shipped to production
Service and deployment engineering for a FAISS-backed RAG service and orchestration code using FastAPI, background autosave and async workers.
Evidence
PredictOutcomes/faiss_manager/faiss_service.py: FastAPI service, InstructionDB with autosave and background worker
jons2003/Self-Learning-Football-Match-Analysis-System/FAISS/faiss_service.py: FAISS index manager, API endpoints and lifespan management
PredictOutcomes/main.py: system orchestration initializing Trainer, Predictor and tagger for workflows
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to efficiency (FAISS usage, batching, disabling GPU for CPU runs) but no measured profiling or advanced GPU/quantization optimization.
Evidence
PredictOutcomes/faiss_manager/faiss_service.py: FAISSIndexManager implementation and use of IndexFlatL2 for nearest neighbors
NeuronetPredictor/core/model.py: os.environ["CUDA_VISIBLE_DEVICES"] = "-1" to control GPU usage
Research Depth & Innovation
2/10
Depth of research and new ideas
Engineering-first research depth; contains creative self-correction and instruction-memory ideas but not rigorous paper-level implementations or reproduced SOTA experiments.
Evidence
Self-Learning-Football-Match-Analysis-System/system/selfLearning_with_correction.py: self-correcting instruction memory and LLMChain correction logic
PredictOutcomes/core/trainer.py: logic to build prompt texts from successful predictions and feed into FAISS
Expertise
LLM• Middle
RAG• Senior
Industries
Sports• Middle
Technologies
Rest API
LangChain
DeepSeek
OpenAI SDK
TensorFlow
Keras
Docker
LLM
RAG
LLM• mentioned only
Recommendations
- Develop retrieval-augmented LLM services and prompt/feedback loops that require FAISS-backed indexing, autosave and prompt improvement pipelines.
- Build end-to-end sports analytics products combining data pipelines, TensorFlow models and LLM-based taggers for feature extraction and human-in-the-loop prompt improvement.
- Implement production hardening: unit/integration tests, experiment tracking (W&B/MLflow), CI/CD and clearer error handling for external APIs and DB operations.
- Work on model/evaluation reproducibility and efficiency: add profiling, resource budgets, and measures (latency/cost) for LLM calls and FAISS searches.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: Medium Data Engineer
Sports ML Engineer specializing in end-to-end football prediction systems that combine classical ML with LLM orchestration and vector search (FAISS). The strongest proven skill is building a FAISS-backed instruction database and accompanying FastAPI service as implemented in faiss_service.py (vector index management, autosave, tag indices and API endpoints). The public code shows limited evidence of unit tests, CI/production hardening, and formal experiment tracking or privacy/security reviews.
Statistical Rigor
3/10
Correct use of statistics
Some sensible evaluation and threshold-selection is present (precision/recall curve, confusion matrices), but formal statistical testing, uncertainty quantification and causal analysis are minimal.
Evidence
NeuronetPredictor/core/model.py: precision_recall_curve and threshold selection logic
NeuronetPredictor/autoencoder/ae_model.py: training metrics and reconstruction error reporting
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Robust preprocessing pipelines and data-cleaning utilities are implemented, with saved preprocessors, outlier clipping and SMOTE balancing; dataset provenance and leakage checks are limited but basic protections (imputers, ColumnTransformer, saved preprocessors) are present.
Evidence
NeuronetPredictor/core_new/prepocessing.py: _normalization, indicators_setup, SMOTE balance and joblib dump of preprocessor
NeuronetPredictor/autoencoder/get_data.py: data_syntetic, clip_outliers_median, fit_normalization
Exploratory Analysis & Visualization
4/10
Exploring and visualizing data
Exploratory plotting and correlation/heatmap utilities exist and there are plotting helpers, but narrative interpretations and statistical follow-ups in code are sparse.
Evidence
NeuronetPredictor/autoencoder/get_data.py: correlation(), hist() and seaborn/matplotlib usage
NeuronetPredictor/autoencoder/ae_model.py: plot_training_history and plot_reconstruction_results
Predictive Modeling
5/10
Building models that predict
End-to-end predictive modeling is implemented with custom models, custom loss/metric, training loops, checkpointing and threshold tuning; however rigorous CV strategies, hyperparameter search infrastructure and unit tests are not evident.
Evidence
NeuronetPredictor/core/model.py: Model_sport class, custom focal_precision_loss integration, training and evaluation flow
NeuronetPredictor/core/custom/custom_focal_loss.py and core/custom/custom_metric_precision1.py: custom loss and metric implementations
Business Insight & Impact
3/10
Turning analysis into business value
Business intent is clear (betting predictions, value-bets, confidence), and some decisions favor precision (high threshold), but explicit cost-based reasoning (FP/FN tradeoffs, ROI calculations) and stakeholder-facing impact analysis are limited.
Evidence
NeuronetPredictor/README.md: project focus on bookmaker odds and binary classification for betting
NeuronetPredictor/core/model.py: computation of confusion matrices and selection of a high prediction threshold
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Reproducibility is partially addressed via requirements files, saved preprocessors, fixed random seeds and ModelCheckpoint callbacks, but there is no evidence of CI, tests, data versioning (DVC), or containerization manifests tied to the code.
Evidence
PredictOutcomes/requirements.txt: pinned dependencies list
NeuronetPredictor/core_new/prepocessing.py: random_state usage and dump/load of preprocessor
Expertise
Analytics• Senior
Big Data• Middle
Industries
Sports• Middle
Technologies
Python• Senior
FAISS
FastAPI
Scikit-learn
Pandas
NumPy
SQLite
TF-Keras
LLM• mentioned only
Recommendations
- Productionize the FAISS service and model pipelines: add unit/integration tests, CI, containerization and secure secret handling for LLM/API keys.
- Add systematic evaluation and monitoring: automated backtests, ROI/FN-FP cost analyses, model drift/quality metrics and alerting for models and prompts.
- Improve reproducibility and data lineage: add DVC or dataset versioning, clearer data provenance, and reproducible training scripts with seeded CV.
- Harden input validation and error handling on API endpoints and remove broad exception swallowing to make failures observable and debuggable.
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
Backend engineer (Python) at a senior-contributing level (tier 4.5) focused on building async APIs and LLM/FAISS-backed ML pipelines. The strongest proven skill is implementing a FAISS-backed vector-search microservice and orchestration with FastAPI and autosave/backup logic (PredictOutcomes/faiss_manager/faiss_service.py). There is limited public evidence of production hardening such as CI/CD, structured observability (tracing/metrics), formal DB migrations, or secure secret management.
API Design
4/10
How well APIs are designed
Solid API engineering with an implemented FastAPI microservice and several custom async API clients, but limited formal versioning, idempotency contracts, or pagination conventions.
Evidence
PredictOutcomes/faiss_manager/faiss_service.py: FastAPI endpoints and Pydantic models (InstructionBase, SearchQuery, endpoints like /instructions/, /search/)
bot_finish/app/binance/binance_API.py: custom async Binance API client with __getattr__ wrapper and request signing
Data Layer & Database
3/10
Working with databases
Uses SQLite and aiosqlite with explicit SQL schemas and query modules, but lacks migration history, transactional boundaries, or explicit tuning of DB isolation.
Evidence
bot_finish/app/db/queries.py: explicit CREATE TABLE / SELECT / INSERT SQL statements
PredictOutcomes/core/database.py: PredictionDatabase class interacting with sqlite3 for storing matches and prompts
Scalability & Performance
4/10
Handling load and speed
Design includes FAISS vector index, background autosave and batching with asyncio, showing awareness of scale, but lacks measured benchmarking, advanced caching invalidation, or production load-handling artefacts.
Evidence
PredictOutcomes/faiss_manager/faiss_service.py: FAISSIndexManager, autosave worker and background threads for persistence
PredictOutcomes/core/predictor.py: process_batch_predictions with batching and pause between batches; use of asyncio.gather in multiple modules
System Architecture
4/10
Overall system structure
Reasonable modular service decomposition - separate FAISS microservice, LLM orchestrator, trainer/predictor/tagger, and a separate trading websockets bot - but no evidence of cross-service contracts, CI/CD, or service mesh/config patterns.
Evidence
PredictOutcomes/main.py: orchestrates Trainer, Predictor, MatchTagger showing deliberate module boundaries
PredictOutcomes/faiss_manager/faiss_service.py: standalone microservice with lifespan management and API surface
Security & Auth
2/10
Protecting data and access
Basic cryptographic signing for Binance API and API-key usage are present, but there is little evidence of secrets handling, input validation, or hardened auth and rate-limit controls.
Evidence
bot_finish/app/binance/binance_API.py: HMAC SHA256 signing and headers in produce_api
bot_finish/app/websockets/ws_listen.py: uses API key in HTTP header to request listenKey and includes reconnect logic
Reliability & Observability
4/10
Stability and monitoring
Good pragmatic reliability patterns - websocket reconnects, retries and adaptive timestamp shifting for Binance, autosave with locking in FAISS service, and try/except logging - but lacks structured tracing, correlation ids and SLI/SLO artifacts.
Evidence
bot_finish/app/binance/binance_API.py: send_api loop with retry handling and adaptive shift_seconds for timestamp errors
PredictOutcomes/faiss_manager/faiss_service.py: lifespan, auto_save_worker thread with error handling and InstructionDB._save_to_file/backup management
bot_finish/app/websockets/ws_listen.py: reconnect loop and error logging around websocket lifecycle
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Senior
Python• Senior
Messaging & Real-time• Middle
Industries
Sports• Senior
Financial Services• Middle
Technologies
Asyncio
Pydantic
Uvicorn
Aiohttp
Recommendations
- Harden production ops for the FAISS service - add authentication, structured logging/tracing, Prometheus metrics and configurable health checks before deploying to cloud.
- Move long-lived secrets out of environment dumps and into a secret manager, and avoid embedding API keys in logs or os.environ strings; introduce input validation on API endpoints.
- Introduce database migration tooling and stronger transactional handling for SQLite usage or migrate to a server DB for concurrent workloads; add tests around DB failures and schema evolution.
- Add end-to-end and integration tests plus CI pipeline to validate cross-service contracts (FAISS client, LLM orchestrator, DB) and add load-testing to measure vector index performance and rate limits.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: