Pooya Torabi
AI Engineer
9+ years exp
Go
JavaScript
Node JS
VHDL
Python
C++
Data Wrangling & Cleaning: 6/10
Exploratory Analysis & Visualization: 6/10
Predictive Modeling: 5/10
Active 12 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A senior-level ML practitioner who designs and runs non-trivial experiments on LLMs with custom pruning and evaluation pipelines. The strongest proven skill is ML engineering for model surgery and evaluation, supported by an implemented Wanda pruning pipeline and calibration hooks (submodules/wanda/prune.py) and coordinated evaluation orchestration (main.py). Limited evidence of production engineering practices - scarce CI/tests, no data versioning, and minimal business metric framing are apparent.
Technical skills
Go
JavaScript
Node JS• Middle
VHDL
Python• Senior
C++
Node JS
Cheerio
Python
Django
Litestar
Flask
Databases
PostgreSQL
Redis
ElasticSearch• 9y+
Neo4j• 9y+
MS SQL
MySQL
AI/ML
Embeddings
LLM
Multimodal AI
Prompt Engineering
RAG
VLM
Datasets
huggingface_hub
NumPy
Pandas
Tokenizers
Scikit-learn
SciPy
Torchvision
spaCy
LangChain
PyTorch
TensorFlow
Transformers
Copilot
DevOps
CI/CD
Docker
GCP
GitLab CI
Vector
Kibana• 9y+
gRPC
Analytics
Matplotlib
Seaborn
Frontend
Vue.js
Timeline
Università degli Studi di Trento
Master's Degree •
Artificial Intelligence Systems
ML Intern
•
Junior
Institute for Research in Fundamental Sciences (IPM)
•
Internship
Studied machine learning and computational neuroscience following the Neuromatch Academy syllabus. Trained a classifier for autism spectrum disorder (ASD) detection as part of the internship work. Applied ML training workflows to develop and evaluate the autism classification model.
Technical Team Lead and Backend Developer
•
Lead
Narvan Startup Studio
•
Full-Time
Led a team of four developers to deliver the initial release of a fintech platform within nine months, coordinating milestones and delivery timelines. Designed, developed, and maintained win-vest.ir, including database design and DevOps responsibilities. Trained a backend developer to take over responsibilities and initiated three MVPs within eight months, contributing to two promotions within that period.
Software Developer and Data Engineer
•
Middle
Gam-Noavaran-Mobtaker
•
Full-Time
Built a system to execute semantic queries over stored entities using Semantic Web technologies and a graph/search data setup. Worked with RDF/SPARQL/OWL concepts and implemented functionality using Neo4j, Elasticsearch, and Kibana. Developed Python automation for data pipeline stages and delivered admin panels and command servers as a full-stack developer, including exploratory security vulnerability proof-of-concepts.
Neo4j
ElasticSearch
Kibana
Amirkabir University of Technology
Bachelor's Degree •
Software Engineering
Senior Data Scientist
Confidence: High ML Practitioner
A senior-level ML practitioner who designs and runs non-trivial experiments on LLMs with custom pruning and evaluation pipelines. The strongest proven skill is ML engineering for model surgery and evaluation, supported by an implemented Wanda pruning pipeline and calibration hooks (submodules/wanda/prune.py) and coordinated evaluation orchestration (main.py). Limited evidence of production engineering practices - scarce CI/tests, no data versioning, and minimal business metric framing are apparent.
Statistical Rigor
4/10
Correct use of statistics
Uses correlation and regression tests for analysis and includes dedicated scripts for correlation analysis, but lacks clear multiple-comparison controls, uncertainty profiling, or formal causal design.
Evidence
analysis/lexicon_corr_acc_change.py
analysis/spearman correlation calc.py
Data Wrangling & Cleaning
6/10
Preparing and cleaning data
Multiple robust dataset loaders and converters for multilingual benchmarks with sampling, parsing and error handling; clear attention to dataset splits and calibration batch construction.
Evidence
benchmark_loader/datautils.py
dataset_utils/hi-paraphrase.py
dataset_utils/ar-paraphrase.py
Exploratory Analysis & Visualization
6/10
Exploring and visualizing data
Substantial plotting and EDA code that produces task-focused visualizations and layered summaries; plots are implemented to answer experimental questions though written narrative/interpretation is limited.
Evidence
analysis/plot_results_old.py
analysis/llm-judge-comparative-heatmap.py
Predictive Modeling
5/10
Building models that predict
Implements non-trivial ML engineering: model loading, forward hooks, calibration, a Wanda-based pruning algorithm and model evaluation pipelines; limited formalization of model selection protocols (e.g., cross-validation reporting) but strong experiment orchestration.
Evidence
submodules/wanda/prune.py
better-VLM-benchmark/model_evaluation/CLIP_evaluator.py
Business Insight & Impact
2/10
Turning analysis into business value
Project is research/experiment-focused with little explicit business framing, cost-of-error analysis, or product/operational impact discussion.
Evidence
README.md
main.py
Reproducibility & Notebook Hygiene
4/10
Clean, repeatable analysis
Reproducibility basics are present - seeding, a setup_environment helper and requirements files - but there is no CI, no data/versioning (DVC), and notebooks/scripts are only partially structured for automated runs.
Evidence
utils.py
language_discovery_pruning/requirements.txt
analysis/plot_results_old.py
Expertise
Analytics• Senior
Industries
Artificial Intelligence• Senior
Technologies
Scikit-learn
Seaborn
Matplotlib
SciPy
spaCy
huggingface_hub
Datasets
Transformers
Pandas
NumPy
Litestar
Torchvision
LLM• mentioned only
Models• mentioned only
VLM• mentioned only
Recommendations
- Lead development of LLM pruning and evaluation pipelines - implement pruning, calibration and evaluation orchestration for research experiments.
- Develop experiment-grade model benchmarking frameworks - reusable loaders, evaluator classes and result logging for multilingual/model-comparison studies.
- Build dataset ingestion and multilingual calibration toolchains - robust parsers, sampling, and tokenizer integration for language-specific benchmarks.
- Implement rigorous reproducibility and CI - add unit tests, CI workflows, environment lockfiles and data/version tracking (DVC or equivalent).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle AI/ML Engineer
Confidence: High ML Engineer
A practical ML engineer focused on evaluation and model sparsification of LLMs, operating at a solid middle level. The strongest proven skill is experimental ML engineering for model pruning and benchmarking, evidenced by the Wanda prune implementation and the evaluation/analysis scripts (submodules/wanda/prune.py and analysis/analysis_utils_old.py). There is limited evidence of production serving, experiment-tracking integration or automated CI and no clear evidence of novel model architecture or large-scale deployment infrastructure.
Model Architecture & Training
4/10
How well models are designed and trained
Solid practical handling of model loading, pruning orchestration and evaluation integration (Wanda pruning integration, model I/O). No evidence of custom neural architectures or full custom training loops - the work focuses on pruning, evaluation and analysis rather than novel model design.
Evidence
submodules/wanda/prune.py::prune_wanda
analysis/analysis_utils_old.py::load_model
main.py::prune
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear, reusable dataset loaders, prompt builders and tokenization helpers for MMLU and XGLUE; language-specific converters and prompt templating are implemented. This is engineering-grade data pipeline work for benchmarking rather than large-scale ETL or production feature stores.
Evidence
benchmark_loader/datautils.py::get_mmlu
benchmark_loader/datautils.py::_build_prompts
dataset_utils/mmlu_converter.py::clean_and_split_choices
Experimentation & Evaluation
5/10
How results are measured and tested
Well-structured experiment and evaluation pipeline - per-model CSV logging, evaluation contracts (EvalSpec), zero-shot evaluation, activation and sensitivity analyses, and cross-benchmark orchestration. The project contains reproducible evaluation scripts but lacks integrated experiment tracking (W&B/MLflow) and automated reproducible run metadata.
Evidence
analysis/analysis_utils_old.py::run_eval_zero_shot_all
analysis/analysis_utils_old.py::get_activation_statistics
main.py::cross_benchmark_evaluation
MLOps & Deployment
3/10
How models are shipped to production
Basic MLOps practices are present: model_dir conventions, asynchronous model saving, moving models to CPU before serialization, and explicit GPU memory cleanup. There is no evidence of serving, versioned model registry, drift monitoring, or CI/CD for model lifecycle management.
Evidence
utils.py::save_pruned_model_async
main.py::prune (uses save_pruned_model_async and model_dir)
Computational Efficiency
3/10
How efficiently computing resources are used
Attention to GPU memory management and practical efficiency (torch_dtype='auto', low_cpu_mem_usage, explicit gc and cuda.empty_cache, batching helpers). No advanced computational-efficiency engineering (no quantization experiments with measured tradeoffs, no low-level kernels, no profiling numbers).
Evidence
analysis/analysis_utils_old.py::load_model (torch_dtype='auto', low_cpu_mem_usage=True)
main.py::prune (moves model to CPU and calls gc, torch.cuda.empty_cache)
Research Depth & Innovation
3/10
Depth of research and new ideas
Applied research-level work: implementation and experimental evaluation of Wanda pruning with layerwise and activation analyses and cross-benchmark experiments. It reads as an applied research/engineering project rather than novel algorithmic contributions or SOTA claims with accompanying ablation papers.
Evidence
submodules/wanda/prune.py::prune_wanda
analysis/analysis_utils_old.py::get_layerwise_weight_distribution
Expertise
LLM• Middle
Industries
Artificial Intelligence• Middle
Technologies
PostgreSQL
Redis
LangChain
Neo4j• 9y+
GCP
Kibana• 9y+
Embeddings
Prompt Engineering
Multimodal AI
VLM
GitLab CI
Tokenizers
CI/CD
TensorFlow
Django
PyTorch
Docker
ElasticSearch• 9y+
LLM
RAG
Vector
Models• mentioned only
VLM• mentioned only
Recommendations
- Lead development of experimental LLM pruning and benchmarking pipelines - implement more structured experiment tracking (W&B/MLflow) and formalize run metadata.
- Build reproducible evaluation suites and analysis dashboards - convert the CSV logging into versioned experiment artifacts with standard metrics and visualizations.
- Productize pruned models by adding a lightweight serving layer and model registry (model versioning, validation and unit/integration tests) before deploying to inference infrastructure.
- Add automated CI and unit/functional tests for the data loaders, eval specs and pruning scripts to improve reproducibility and reliability of experiments.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium Generalist
A practical engineer focused on LLM research tooling and experimental evaluation pipelines at a middle level. The strongest proven skill is building model-analysis and pruning pipelines using PyTorch/transformers, evidenced by get_layerwise_weight_distribution, activation and attention-head statistics, and the prune orchestration in main.py. There is limited evidence of production-grade API design, secrets management, tests, or structured observability in public code.
API Design
2/10
How well APIs are designed
Minimal API surface - CLI-style orchestration exists but there is no evidence of REST/HTTP API contracts, versioning, idempotency keys or consistent error contract design.
Evidence
language_discovery_pruning/main.py: functions evaluate_raw_model, prune - CLI orchestration
language_discovery_pruning/evaluation/common_evaluation.py: EvalSpec.evaluate_on_linguistic - evaluation contract used internally
Data Layer & Database
2/10
Working with databases
Data layer is file/CSV based with ad-hoc read/write; no DB schema, migrations, or explicit transaction/isolation handling are present.
Evidence
language_discovery_pruning/analysis/analysis_utils_old.py: writes CSVs in get_layerwise_weight_distribution and get_activation_statistics
language_discovery_pruning/analysis/plot_results_old.py: reads and parses CSV files like results/layerwise_weight_distribution.csv
Scalability & Performance
3/10
Handling load and speed
Shows awareness of runtime constraints - GPU memory management and background saving of large artifacts - but lacks comprehensive, production-grade scalability patterns (no measured optimization reports, cache invalidation, or rate limiting).
Evidence
language_discovery_pruning/analysis/analysis_utils_old.py: clear_gpu_memory, load_model uses low_cpu_mem_usage and explicit cuda handling
language_discovery_pruning/main.py: save_pruned_model_async usage and threaded background saving of large model files
System Architecture
3/10
Overall system structure
A deliberate experimental pipeline and modular layout (benchmark loaders, eval specs, pruning submodule) show intentional decomposition for experiments, but this is research-oriented rather than a production microservice architecture.
Evidence
language_discovery_pruning/main.py: LINGUISTIC_BENCHMARKS mapping and orchestration of evaluation/prune/cross_eval flows
language_discovery_pruning/evaluation/common_evaluation.py and benchmark_loader/datautils.py: separate modules for loading and evaluation contracts
Security & Auth
2/10
Protecting data and access
Limited security posture - credentials and trust flags are used but there is no evidence of secrets management, input sanitization, or defensive controls around remote code execution.
Evidence
language_discovery_pruning/utils.py: setup_environment logs into Hugging Face via huggingface_hub.login (HF_TOKEN referenced in docs)
language_discovery_pruning/analysis/analysis_utils_old.py: monkey-patches datasets.load_dataset to set trust_remote_code=True
Reliability & Observability
3/10
Stability and monitoring
Basic reliability patterns - try/except to continue on errors, explicit resource cleanup, CSV logging and flush, and thread joins - but lacks structured observability (centralized metrics, correlation ids, or alerting hooks).
Evidence
language_discovery_pruning/analysis/analysis_utils_old.py: many try/except blocks plus explicit clear_gpu_memory calls
language_discovery_pruning/main.py: writer.flush() after logging and joining background save threads
Expertise
Backend AI & LLM• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Technologies
Python• Senior
Go
Node JS• Middle
Cheerio
Recommendations
- Develop research-to-production model evaluation pipelines - expand the existing pruning/eval scripts into repeatable CI workflows with artifact versioning and reproducible envs.
- Build scalable model-saving and orchestration components - add resumable uploads, controlled concurrency, and safe serialization (avoid exposing secrets) around save_pruned_model_async.
- Harden data and security practices - remove trust_remote_code monkey-patches, add explicit secrets handling (vault/OS env reading), and add input validation for dataset loaders.
- Productize plotting/reporting - add structured metrics (Prometheus/OpenTelemetry) and unit/integration tests around key analysis functions like activation and attention stats.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: