[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"me":3,"catalog:en:ml-engineer\u002Fti-training-determinism-numerics":4,"config":212},null,{"field_key":5,"field_name":6,"seniority":7,"topic_key":8,"topic_name":9,"spec_key":7,"spec_name":7,"locale":10,"cell_total":11,"field_total":12,"seniorities":13,"topics":17,"specs":112,"samples":126},"ml-engineer","ML Engineer","","ti-training-determinism-numerics","Ti Training Determinism Numerics","en",75,2400,[14,15,16],"junior","mid","senior",[18,21,24,27,30,33,36,39,42,45,48,51,54,57,60,63,66,69,72,75,78,81,84,87,90,93,96,99,102,105,108,111],{"key":19,"name":20,"count":11},"cml-distance-clustering-dimreduction","Cml Distance Clustering Dimreduction",{"key":22,"name":23,"count":11},"cml-gradient-boosting-mechanics","Cml Gradient Boosting Mechanics",{"key":25,"name":26,"count":11},"cml-linear-logistic-internals","Cml Linear Logistic Internals",{"key":28,"name":29,"count":11},"cml-probabilistic-models-calibration","Cml Probabilistic Models Calibration",{"key":31,"name":32,"count":11},"cml-svm-kernels-margins","Cml Svm Kernels Margins",{"key":34,"name":35,"count":11},"cml-trees-randomforest-internals","Cml Trees Randomforest Internals",{"key":37,"name":38,"count":11},"dl-architecture-layers","Dl Architecture Layers",{"key":40,"name":41,"count":11},"dl-initialization-optimizers","Dl Initialization Optimizers",{"key":43,"name":44,"count":11},"dl-losses-output-layers","Dl Losses Output Layers",{"key":46,"name":47,"count":11},"dl-normalization-regularization","Dl Normalization Regularization",{"key":49,"name":50,"count":11},"dl-sequence-attention","Dl Sequence Attention",{"key":52,"name":53,"count":11},"dl-training-dynamics-backprop","Dl Training Dynamics Backprop",{"key":55,"name":56,"count":11},"fe-binning-discretization","Fe Binning Discretization",{"key":58,"name":59,"count":11},"fe-categorical-encoding-mechanics","Fe Categorical Encoding Mechanics",{"key":61,"name":62,"count":11},"fe-interactions-basis-expansion","Fe Interactions Basis Expansion",{"key":64,"name":65,"count":11},"fe-numeric-transforms-distributions","Fe Numeric Transforms Distributions",{"key":67,"name":68,"count":11},"fe-temporal-cyclical-features","Fe Temporal Cyclical Features",{"key":70,"name":71,"count":11},"fe-text-highcardinality-features","Fe Text Highcardinality Features",{"key":73,"name":74,"count":11},"ml-data-preparation","Ml Data Preparation",{"key":76,"name":77,"count":11},"ml-deployment-serving","Ml Deployment Serving",{"key":79,"name":80,"count":11},"ml-experimentation-reproducibility","Ml Experimentation Reproducibility",{"key":82,"name":83,"count":11},"ml-model-selection-tuning","Ml Model Selection Tuning",{"key":85,"name":86,"count":11},"ml-model-training-evaluation","Ml Model Training Evaluation",{"key":88,"name":89,"count":11},"ml-monitoring-drift","Ml Monitoring Drift",{"key":91,"name":92,"count":11},"ml-problem-framing","Ml Problem Framing",{"key":94,"name":95,"count":11},"ml-scaling-performance","Ml Scaling Performance",{"key":97,"name":98,"count":11},"ti-checkpointing-fault-tolerance","Ti Checkpointing Fault Tolerance",{"key":100,"name":101,"count":11},"ti-cluster-scheduling-resources","Ti Cluster Scheduling Resources",{"key":103,"name":104,"count":11},"ti-distributed-strategies-sync","Ti Distributed Strategies Sync",{"key":106,"name":107,"count":11},"ti-input-pipeline-throughput","Ti Input Pipeline Throughput",{"key":109,"name":110,"count":11},"ti-throughput-profiling-bottlenecks","Ti Throughput Profiling Bottlenecks",{"key":8,"name":9,"count":11},[113,117,120,123],{"key":114,"name":115,"count":116},"classical-ml","Classical ML",450,{"key":118,"name":119,"count":116},"deep-learning","Deep Learning",{"key":121,"name":122,"count":116},"feature-engineering","Feature Engineering",{"key":124,"name":125,"count":116},"training-infrastructure","Training Infrastructure",[127,145,159,172,185,199],{"id":128,"topic":9,"difficulty":129,"body":130,"options":131,"correct_key":139,"explanation":144},"01a05d13-8e1e-74ea-8732-d1a9cd5936b2",3,"```python\na = torch.tensor(1.0e16, dtype=torch.float32)\nb = torch.tensor(1.0, dtype=torch.float32)\nc = torch.tensor(-1.0e16, dtype=torch.float32)\nprint(((a + b) + c).item())\nprint((a + (b + c)).item())\nprint(((a + c) + b).item())\n```\nThis prints `0.0`, `0.0`, then `1.0`. All three lines add the same three numbers. What explains the third result differing from the first two?",[132,135,138,141],{"key":133,"text":134},"a","A print-statement bug swapped which variable each line displays",{"key":136,"text":137},"b","`torch.tensor` cached the first two calls and returned a stale value",{"key":139,"text":140},"c","The grouping order changed, and float32 addition isn't associative",{"key":142,"text":143},"d","Float32 addition is undefined whenever a negative operand appears","`(a + c)` cancels the two huge-magnitude values to `0.0` first, so the remaining `+ b` leaves exactly `1.0`. In the first two groupings, `1.0` is combined with `1e16` before the cancellation — and `1e16` in float32 can't represent an increment of `1.0`, so it rounds away (c). There's no print bug (a), no caching in `torch.tensor` (b), and negative operands are perfectly well-defined in IEEE 754 (d).",{"id":146,"topic":9,"difficulty":147,"body":148,"options":149,"correct_key":133,"explanation":158},"01a05d13-8e1f-7a13-a7b8-da651393b196",1,"A trainee reruns the exact same single-GPU training step twice with an identical seed, but changes how the per-sample losses in a batch are summed (left-to-right loop vs. a tree-shaped pairwise sum). The two totals differ in the last couple of decimal digits. What is the most accurate description?",[150,152,154,156],{"key":133,"text":151},"An expected effect, since floating-point addition is not associative",{"key":136,"text":153},"A sign the random seed wasn't actually applied on one run",{"key":139,"text":155},"Only possible if one summation method has an indexing bug",{"key":142,"text":157},"Not expected unless the two runs used different hardware","Floating-point addition is not associative: `(x+y)+z` and `x+(y+z)` can round differently even though both are mathematically the same sum. Changing the summation strategy changes the grouping, so a small last-digit difference is expected, not a bug (a). The seed governs randomness, not deterministic summation order (b). No indexing bug is required (c), and this has nothing to do with hardware differences between the two runs (d).",{"id":160,"topic":9,"difficulty":129,"body":161,"options":162,"correct_key":133,"explanation":171},"01a05d13-8e24-770f-a76f-cf5cb7fbe31e","A team reruns the exact same training script — identical code, data, and a fixed seed — on two machines that differ only in which minor version of PyTorch happens to be installed (a routine dependency update landed on one of them). The final loss differs starting from step 1 by a tiny amount. Is this necessarily a sign that the seed wasn't fixed correctly?",[163,165,167,169],{"key":133,"text":164},"No — a fixed seed pins randomness only, not which kernel a library version ships",{"key":136,"text":166},"Yes — a fixed seed guarantees bit-identical results regardless of which library version is installed",{"key":139,"text":168},"No — that would require PyTorch to silently disable seeding whenever it detects a version mismatch, which is not what happens",{"key":142,"text":170},"Yes, but only if the two machines also run different operating systems","A fixed seed controls the sequence of 'random' numbers produced, but says nothing about which specific kernel implementation or default algorithm a given library version ships — a routine version bump can change a default kernel's internal grouping or algorithm choice, producing a tiny but genuine rounding difference even with byte-identical code, data, and seed (a). The seed doesn't extend any guarantee across library versions (b). Nothing about a version difference disables seeding (c), and this isn't specifically an operating-system issue (d).",{"id":173,"topic":9,"difficulty":147,"body":174,"options":175,"correct_key":136,"explanation":184},"01a05d13-8e28-71c1-ad75-e8524ee878f2","In a 4-rank data-parallel job, every rank calls `torch.manual_seed(42)` right before building its augmentation pipeline. Each rank still sees a different shard of images. What is the observable consequence?",[176,178,180,182],{"key":133,"text":177},"Augmentation differs across ranks anyway, since DataLoader ignores this seed",{"key":136,"text":179},"Every rank's augmentation stream produces the same sequence of decisions",{"key":139,"text":181},"The job crashes since the seed value is identical on more than one rank",{"key":142,"text":183},"Random augmentation is disabled once an identical seed is detected twice","Seeding every rank with the same value puts every rank's RNG generator into the identical internal state, so the k-th draw from that generator is the same number on every rank; whatever augmentation decision that number maps to therefore lands at the same position in each rank's pipeline, just applied to that rank's own images (b). Nothing here disables augmentation or crashes the job (c, d), and DataLoader does respect a seed set this way (a).",{"id":186,"topic":9,"difficulty":187,"body":188,"options":189,"correct_key":142,"explanation":198},"01a05d13-8e29-72de-ab6a-581ee4c31c9b",2,"```python\nt = torch.tensor([1.0, 3.0, 3.0, 2.0, 3.0])\nprint(t.argmax().item())\n```\nThe maximum `3.0` appears at indices 1, 2, and 4. What does this print?",[190,192,194,196],{"key":133,"text":191},"4, the last index holding the maximum value",{"key":136,"text":193},"A different index chosen at random on each run",{"key":139,"text":195},"A RuntimeError, since the maximum isn't unique",{"key":142,"text":197},"1, the first index holding the maximum value","`torch.argmax()` deterministically returns the first index at which the maximum occurs — here index 1 (d), not the last (a) and not a random pick (b). It runs without error on ties (c).",{"id":200,"topic":9,"difficulty":187,"body":201,"options":202,"correct_key":139,"explanation":211},"01a05d13-8e2b-7262-8e65-df5cd8a63eda","Two runs of the same GPU step, same inputs, same seed, use a gradient-scatter kernel that accumulates contributions from many threads with atomic add instructions. The resulting gradients differ at the last few mantissa bits. What is the most direct cause?",[203,205,207,209],{"key":133,"text":204},"The GPU's memory cache silently retains stale gradient values left over between the two runs",{"key":136,"text":206},"The randomness comes from the CPU host code, not the GPU kernel",{"key":139,"text":208},"Atomic-add accumulation doesn't fix arrival order",{"key":142,"text":210},"This can only happen on an unsupported PyTorch installation","Atomic-add kernels let threads add into a shared accumulator whenever they finish, and thread completion order isn't fixed between runs — so the summation order, and hence the exact rounded float result, can vary run to run even with identical inputs (c). No stale-value caching is involved (a); the source is the GPU kernel's execution order, not host-side code (b); and this is a documented property, not corruption (d).",{"fields":213,"seniorities":436,"interview_shapes":437,"locales":442,"oauth":444,"question_count":447,"coach_enabled":448,"jd_match_enabled":448},[214,239,259,275,299,312,331,350,372,391,406,428],{"key":215,"name_tr":216,"name_en":216,"sort":147,"specializations":217},"backend","Backend",[218,221,224,227,230,233,236],{"key":219,"name":220,"field":215},"general","Genel",{"key":222,"name":223,"field":215},"go","Go",{"key":225,"name":226,"field":215},"python","Python",{"key":228,"name":229,"field":215},"java","Java",{"key":231,"name":232,"field":215},"csharp","C#\u002F.NET",{"key":234,"name":235,"field":215},"nodejs","Node.js",{"key":237,"name":238,"field":215},"php","PHP",{"key":240,"name_tr":241,"name_en":241,"sort":187,"specializations":242},"frontend","Frontend",[243,244,247,250,253,256],{"key":219,"name":220,"field":240},{"key":245,"name":246,"field":240},"javascript","JavaScript",{"key":248,"name":249,"field":240},"typescript","TypeScript",{"key":251,"name":252,"field":240},"react","React",{"key":254,"name":255,"field":240},"vue","Vue",{"key":257,"name":258,"field":240},"angular","Angular",{"key":260,"name_tr":261,"name_en":261,"sort":129,"specializations":262},"fullstack","Fullstack",[263,264,265,266,267,268,269,270,271,272,273,274],{"key":219,"name":220,"field":260},{"key":222,"name":223,"field":215},{"key":225,"name":226,"field":215},{"key":228,"name":229,"field":215},{"key":231,"name":232,"field":215},{"key":234,"name":235,"field":215},{"key":237,"name":238,"field":215},{"key":245,"name":246,"field":240},{"key":248,"name":249,"field":240},{"key":251,"name":252,"field":240},{"key":254,"name":255,"field":240},{"key":257,"name":258,"field":240},{"key":276,"name_tr":277,"name_en":277,"sort":278,"specializations":279},"devops-cloud","DevOps \u002F Cloud",4,[280,281,284,287,290,293,296],{"key":219,"name":220,"field":276},{"key":282,"name":283,"field":276},"aws","AWS",{"key":285,"name":286,"field":276},"gcp","GCP",{"key":288,"name":289,"field":276},"azure","Azure",{"key":291,"name":292,"field":276},"kubernetes","Kubernetes",{"key":294,"name":295,"field":276},"terraform","Terraform",{"key":297,"name":298,"field":276},"linux","Linux",{"key":300,"name_tr":301,"name_en":301,"sort":302,"specializations":303},"ai-engineer","AI Engineer",5,[304,305,306,309],{"key":219,"name":220,"field":300},{"key":225,"name":226,"field":300},{"key":307,"name":308,"field":300},"llm-rag","LLM\u002FRAG",{"key":310,"name":311,"field":300},"mlops","MLOps",{"key":313,"name_tr":314,"name_en":315,"sort":316,"specializations":317},"database","Veritabanı","Database",6,[318,319,322,325,328],{"key":219,"name":220,"field":313},{"key":320,"name":321,"field":313},"postgresql","PostgreSQL",{"key":323,"name":324,"field":313},"mysql","MySQL",{"key":326,"name":327,"field":313},"mongodb","MongoDB",{"key":329,"name":330,"field":313},"redis","Redis",{"key":332,"name_tr":333,"name_en":334,"sort":335,"specializations":336},"mobile","Mobil","Mobile",7,[337,338,341,344,347],{"key":219,"name":220,"field":332},{"key":339,"name":340,"field":332},"ios-swift","iOS (Swift)",{"key":342,"name":343,"field":332},"android-kotlin","Android (Kotlin)",{"key":345,"name":346,"field":332},"flutter","Flutter",{"key":348,"name":349,"field":332},"react-native","React Native",{"key":351,"name_tr":352,"name_en":353,"sort":354,"specializations":355},"security","Güvenlik","Security",8,[356,357,360,363,366,369],{"key":219,"name":220,"field":351},{"key":358,"name":359,"field":351},"appsec","AppSec",{"key":361,"name":362,"field":351},"offensive-pentest","Offensive \u002F Pentest",{"key":364,"name":365,"field":351},"cloud-security","Cloud Security",{"key":367,"name":368,"field":351},"devsecops","DevSecOps",{"key":370,"name":371,"field":351},"blue-team-incident","Blue Team \u002F Incident",{"key":373,"name_tr":374,"name_en":375,"sort":376,"specializations":377},"qa-test-automation","QA \u002F Test Otomasyonu","QA \u002F Test Automation",9,[378,379,382,385,388],{"key":219,"name":220,"field":373},{"key":380,"name":381,"field":373},"test-automation","Test Automation",{"key":383,"name":384,"field":373},"sdet","SDET",{"key":386,"name":387,"field":373},"performance-testing","Performance Testing",{"key":389,"name":390,"field":373},"mobile-qa","Mobile QA",{"key":392,"name_tr":393,"name_en":393,"sort":394,"specializations":395},"data-engineer","Data Engineer",10,[396,397,400,403],{"key":219,"name":220,"field":392},{"key":398,"name":399,"field":392},"pipelines-etl","Pipelines \u002F ETL",{"key":401,"name":402,"field":392},"streaming","Streaming",{"key":404,"name":405,"field":392},"warehousing","Warehousing",{"key":407,"name_tr":408,"name_en":409,"sort":410,"specializations":411},"game-dev","Oyun Geliştirme","Game Development",11,[412,413,416,419,422,425],{"key":219,"name":220,"field":407},{"key":414,"name":415,"field":407},"unity-csharp","Unity (C#)",{"key":417,"name":418,"field":407},"unreal-cpp","Unreal (C++)",{"key":420,"name":421,"field":407},"gameplay","Gameplay",{"key":423,"name":424,"field":407},"graphics-rendering","Graphics \u002F Rendering",{"key":426,"name":427,"field":407},"multiplayer-netcode","Multiplayer \u002F Netcode",{"key":5,"name_tr":6,"name_en":6,"sort":429,"specializations":430},12,[431,432,433,434,435],{"key":219,"name":220,"field":5},{"key":114,"name":115,"field":5},{"key":121,"name":122,"field":5},{"key":118,"name":119,"field":5},{"key":124,"name":125,"field":5},[14,15,16],{"junior":438,"mid":440,"senior":441},{"questions":439,"median_sec":3},20,{"questions":439,"median_sec":3},{"questions":439,"median_sec":3},[443,10],"tr",[445,446],"google","github",28950,true]