Git version control basics

1.4.11 · AI-ML › Python & Scientific Computing

Essential Commands - Workflow Se Derived

1. Initializing aur Cloning

Formula Repository Start Karna

Option A: Naya repo create karo

git init

Current folder mein .git directory create karta hai
HEAD ko refs/heads/main ki taraf point karte hue initialize karta hai Option B: Existing repo clone karo

git clone <url>

Remote se poori history download karta hai
Remote tracking branch automatically set up karta hai
Latest commit checked out ke saath working directory create karta hai

CLONE KYUN? Tumhe poori history locally milti hai—tum offline kaam kar sakte ho aur complete backup hoti hai.

2. Basic Workflow Commands

Formula Add-Commit Cycle

# 1. Status check karo
git status
# Dikhata hai: untracked, modified, staged files
# 2. Specific files stage karo
git add <file1> <file2>
# Ya saari changes stage karo:
git add .
# 3. Message ke saath commit karo
git commit -m "Add feature X"
# Descriptive message ke saath snapshot create karta hai
 
# 4. History dekho
git log --oneline --graph
# Commit tree visually dikhata hai

DERIVATION: Ye sequence kyun?

status → current state samjho
add → curate karo kya next commit mein jaayega (atomic changes)
commit → snapshot ko context ke saath finalize karo (message)
log → history graph verify karo

3. Branching aur Merging

Formula Branch Operations

Branches create karna aur switch karna:

# Nayi branch create karo
git branch feature-x
# Uspe switch karo
git checkout feature-x
# Ya dono ek command mein:
git checkout -b feature-x

KYUN?

branch current commit ki taraf ek naya pointer create karta hai
checkout HEAD ko us branch ki taraf point karne ke liye update karta hai
HEAD decide karta hai ki nayi commits kis branch pe jaayengi Changes merge karke wapas laana:

git checkout main
git merge feature-x

MERGE KAISE KAAM KARTA HAI:

Fast-forward merge: Agar main diverge nahi hui hai, toh bas pointer aage move karo
Three-way merge: Agar dono branches mein nayi commits hain, toh Git do parents ke saath ek merge commit create karta hai $Merge = Find common ancestor + Apply both sets of changes$

4. Remote Operations

Formula Remote Ke Saath Synchronize Karna

# Remote repository add karo
git remote add origin <url>
 
# Local commits remote pe push karo
git push origin main
# origin = remote name, main = branch
 
# Remote se updates fetch karo (merge nahi karta)
git fetch origin
 
# Pull = fetch + merge
git pull origin main

PUSH MEIN KYA HOTA HAI:

Git local commits ko remote HEAD se compare karta hai
Missing commit objects network pe bhejtaa hai
Remote branch pointer update karta hai
Fast-forward tabhi karta hai jab koi conflicts na hon

MERGE SE PEHLE FETCH KYUN? Changes review karne deta hai unhe apne kaam mein integrate karne se pehle.

Worked Examples

Worked example Example 1: Git Ke Saath Naya ML Project Create Karna

Scenario: Tum ek naya machine learning project start kar rahe ho aur pehle din se hi version control chahte ho.

# Step 1: Project directory create karo
mkdir ml-classifier
cd ml-classifier

Kyun? Ek clean directory structure se shuru karo.

# Step 2: Git initialize karo
git init

Ye step kyun? History track karne ke liye .git folder create karta hai. Ab har change record ho sakti hai.

# Step 3: Initial files create karo
echo "# ML Classifier Project" > README.md
echo "*.pyc\n__pycache__/\n.venv/" > .gitignore

Kyun .gitignore? Git ko compiled files aur virtual environments ignore karne ko kehta hai—auto-generated files track nahi karni chahiye.

# Step 4: Stage aur commit karo
git add README.md .gitignore
git commit -m "Initial commit: Add README and gitignore"

Ye step kyun? Pehla snapshot create karta hai. Message describe karta hai ki commit mein kya hai.

# Step 5: Status check karo
git log --oneline
# Output: e7f3a2c (HEAD -> main) Initial commit: Add README and gitignore

Check kyun? Verify karo ki commit create hui aur HEAD main branch ki taraf point kar raha hai.

Worked example Example 2: Feature Branch Workflow

Scenario: Tumhe main codebase ko break kiye bina ek data preprocessing module add karna hai.

# Step 1: Feature branch create karo aur switch karo
git checkout -b feature/preprocessing

Kyun? Tumhara kaam isolate karta hai. Main branch stable rehti hai jab tum experiment karte ho.

# Step 2: Preprocessing module create karo
cat > preprocessing.py << 'EOF'
import pandas as pd
def clean_data(df):
    """Remove null values and duplicates"""
    return df.dropna().drop_duplicates()
EOF

File kyun create karo? Ye actual feature hai jo tum build kar rahe ho.

# Step 3: Stage aur commit karo
git add preprocessing.py
git commit -m "Add data cleaning function"

Ye message kyun? Added functionality describe karta hai, implementation details nahi.

# Step 4: Ek aur commit karo (iterative work)
cat >> preprocessing.py << 'EOF'
def normalize_features(df):
    """Scale features to [0,1] range"""
    return (df - df.min()) / (df.max() - df.min())
EOF
git add preprocessing.py
git commit -m "Add feature normalization"

Alag commit kyun? Har commit ek logical change honi chahiye. Revert karna aasaan hoga agar normalization mein bugs hain.

# Step 5: Main mein wapas merge karo
git checkout main
git merge feature/preprocessing

Ye step kyun? Working feature ko main codebase mein integrate karta hai.

# Step 6: Feature branch delete karo (optional)
git branch -d feature/preprocessing

Delete kyun? Branch list clean rakhta hai. Commits abhi bhi main ki history mein hain.

Worked example Example 3: Remote Repository Ke Saath Collaborate Karna

Scenario: Tum GitHub pe ek team ke saath kaam kar rahe ho. Tumhe apne changes push karne hain aur teammate updates pull karni hain.

# Step 1: Remote repository se link karo
git remote add origin https://github.com/username/ml-classifier.git

Kyun? Remote server se connection establish karta hai. "origin" primary remote ka conventional naam hai.

# Step 2: Apne local commits push karo
git push -u origin main

Kyun -u flag? Tracking relationship set up karta hai: git push aage future mein origin main pe default karega.

Internally kya hota hai:

Git commit objects compress karta hai
Unhe HTTPS/SSH pe bhejta hai
Remote apna main branch pointer update karta hai

# Step 3: Teammate changes karta hai, tumhe update karna hai
git pull origin main

Pull kyun? Teammate ke commits download karta hai aur unhe tumhare local main mein merge karta hai.

Agar conflicts hain:

# Git files mein conflict markers dikhata hai:
<<<<<<< HEAD
Your changes
=======
Teammate's changes
>>>>>>> commit-hash
# Manually resolve karo, phir:
git add <resolved-file>
git commit -m "Merge branch 'main' of origin"

Manual resolution kyun? Git decide nahi kar sakta kaun si version sahi hai—human judgment chahiye.

Common Mistakes

Common mistake Mistake 1: Staging Ke Bina Commit Karna

Galat approach:

# Modified train.py
git commit -m "Update model"
# Error: no changes added to commit

Ye sahi kyun lagta hai: Un systems se aana jahan "save" directly changes persist karta hai.

Steel-man: Ye two-step process redundant lagti hai—directly commit kyun nahi?

Fix:

git add train.py
git commit -m "Update model architecture"

Staging kyun exist karta hai: Tumhe apne changes ka part commit karne deta hai. Tumne 5 files modify ki hongi par sirf 2 related changes commit karni hain. Staging fine-grained control deta hai.

Shortcut (carefully use karo):

git commit -am "Update model"  # -a saari tracked modified files stage karta hai

Common mistake Mistake 2: Vague Commit Messages

Galat approach:

git commit -m "fix"
git commit -m "updates"
git commit -m "changes"

Ye sahi kyun lagta hai: Tum jaante ho tumne abhi kya change kiya, toh details unnecessary lagti hain.

Steel-man: Detailed messages likhna development flow slow kar deta hai.

Fix:

git commit -m "Fix null pointer error in data loader
- Add null check before accessing dataframe columns
- Return empty list instead of None for edge case
- Fixes issue #42"

Ye kyun matter karta hai: 3 mahine baad, tum (ya koi teammate) samajhna chahoge ki ye change kyun ki gayi thi. git blame aur git log vague messages ke saath useless ho jaate hain. Achhe messages:

Describe karte hain kya change hua
Explain karte hain kyun (agar obvious nahi hai)
Issues/tickets reference karte hain

Format convention:

<type>: <short summary> (50 chars max)
<detailed explanation> (72 chars per line)

Common mistake Mistake 3: .gitignore Use Na Karna

Galat approach:

git add .
# Accidentally commits:
# - __pycache__/
# - .venv/
# - .env (with API keys!)
# - dataset.csv (100MB)

Ye sahi kyun lagta hai: git add . quick hai aur comprehensive lagta hai.

Steel-man: Tum reproducibility ke liye sab kuch version-control mein chahte ho.

Fix:

# Pehle .gitignore create karo
cat > .gitignore << 'EOF'
# Python
__pycache__/*.pyc
.venv/
venv/
# Environment variables (KABHI bhi secrets commit mat karo!)
.env
.env.local
# Data files (Git ke liye bahut bade)
*.csv
*.h5
data/
 
# IDE
.vscode/
.idea/
# Model checkpoints (Git LFS ya external storage use karo)
*.pth
*.ckpt
EOF
git add .gitignore
git commit -m "Add gitignore for Python ML project"

Ye kyun matter karta hai:

Security: API keys, passwords leak hone se bachata hai
Size: Git source code ke liye design kiya gaya hai, large binaries ke liye nahi
Cleanliness: Auto-generated files se history pollute hone se bachata hai Agar tumne already secrets commit kar diye hain:

# History se remove karo (DANGEROUS—history rewrite karta hai)
git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch .env" --prune-empty --tag-name-filter cat -- --all
# Phir: IMMEDIATELY exposed credentials rotate karo

Common mistake Mistake 4: Review Kiye Bina Merging

Galat approach:

git merge feature-x
# Auto-merge failed, conflicts in train.py
# User bina padhhe saari incoming changes accept kar leta hai
git add train.py
git commit -m "Merge feature-x"
# Result: main branch mein broken code

Ye sahi kyun lagta hai: Conflicts frustrating hote hain—bas aage badhna chahte hain.

Steel-man: Feature branch test ki gayi thi, toh sahi honi chahiye.

Fix:

git merge feature-x
# Conflict in train.py
# 1. File open karo, conflict markers dhundho
# <<<<<<< HEAD
# model = LinearRegression()
# ======
# model = RandomForestRegressor()
# >>>>>>> feature-x
# 2. DONO versions samjho
# - HEAD: main branch linear model use karti hai
# - feature-x: naya branch random forest use karta hai
# 3. Context ke basis pe decide karo (shayad feature-x version rakho)
# Markers remove karo, ek version rakho:
# model = RandomForestRegressor()
# 4. Commit karne se pehle test karo
python -m pytest tests/
# 5. Verification ke baad hi stage aur commit karo
git add train.py
git commit -m "Merge feature-x: Switch to random forest model
 
Resolved conflict by choosing RF over linear regression.
All tests passing."

Ye process kyun: Merges bina conflicts ke bhi subtle bugs introduce kar sakti hain. Merged result ko hamesha test karo.

Git Workflow Patterns

Formula Feature Branch Workflow (Industry Standard)

Pattern:

2. Create feature branch
3. Make commits on feature branch
4. Push feature branch to remote
5. Open pull request (PR)
6. Code review
7. Merge to main
8. Delete feature branch

Mathematical model: Har branch commits ka ek directed acyclic graph (DAG) hai.

$Branch_{feature} = Branch_{main} + Δ commits$

$Merge : Branch_{main} \leftarrow Branch_{main} \cup Δ commits$

DAG KYUN? Commits ke multiple parents ho sakte hain (merge commits) par koi cycles nahi—tum past mein commit nahi kar sakte.

ML Projects Ke Liye Best Practices

Formula ML-Specific Git Practices

1. Large datasets ya models commit mat karo

50MB files ke liye Git LFS (Large File Storage) use karo
Ya cloud mein store karo (S3, GCS) aur download scripts commit karo

2. Apna data aur code saath version karo

# train.py mein
DATA_VERSION = "v2.3"  # Corresponds to s3://bucket/data-v2.3/
MODEL_VERSION = "0.41"

3. Sirf code nahi, experiment configs bhi commit karo

# config.yaml (Git dwara tracked)
model:
  type: "random_forest"
  n_estimators: 100
  max_depth: 10
data:
  version: "v2.3"

4. Production models ke liye tags use karo

git tag -a v1.0 -m "First production model"
git push origin v1.0

KYUN? Tags specific commits ko significant mark karte hain. Tum hamesha v1.0 checkout kar sakte ho exact production model reproduce karne ke liye.

Recall Feynman Explanation (12-saal ke bachche ko samjhao)

Socho tum ek magic notebook mein ek kahani likh rahe ho. Har baar jab tum ek chapter khatam karte ho, tum ek button daba sakte ho jiska naam hai "Save Checkpoint" (ye ek commit hai). Magic notebook har checkpoint yaad rakhti hai jo tumne kabhi bhi dabaaya.

Agar tum kuch likhte ho aur baad mein pasand nahi aata, tum kisi bhi purani checkpoint pe wapas ja sakte ho aur wahan se phir se shuru kar sakte ho. Tumhara purana kaam kabhi nahi jaata!

Ab, maan lo tum apni kahani ke liye ek alag ending try karna chahte ho. Tum ek branch create karte ho—ye tumhari kahani ke liye ek parallel universe jaisi hai. Is branch mein, hero alag tarike se jeetta hai. Main kahani mein, sab same rehta hai. Baad mein, agar nayi ending pasand aaye, tum use main kahani mein merge kar sakte ho.

Tumhare dost ke paas bhi magic notebook ki ek copy hai (unke computer pe). Jab tum dono changes karte ho, tum apne checkpoints ek shared cloud notebook (GitHub) pe push karte ho, aur tum unke checkpoints pull karte ho dekhne ke liye ki unhone kya likha. Agar tum dono ne ek hi sentence change kiya, toh tumhare paas ek conflict hai—tumhe decide karna hoga kiska version rakhna hai. Yahi hai Git! Ye tumhare code ke liye time machine + parallel universes + cloud sharing hai.

Connections

1.4.10-Command-line-interface - Git primarily CLI ke zariye use hota hai
1.4.12-GitHub-workflows - Remote collaboration patterns
2.1.3-Jupyter-notebooks - Git .ipynb ke saath kaam karta hai par diffs messy hote hain (nbdime use karo)
3.2.5-Experiment-tracking - Version control MLflow, Weights & Biases ke saath integrate hota hai
4.1.8-CI-CD-pipelines - Git automated testing aur deployment trigger karta hai
5.3.2-Model-versioning - Similar concepts ML artifacts pe apply hote hain

#flashcards/ai-ml

Git repository kya hai? :: Ek directory jo Git dwara tracked hai, jisme project files aur ek .git folder hota hai jisme complete version history, commits, aur branch metadata hoti hai.

Git mein files ki teen states kya hain?

Modified (working directory), Staged (index/staging area), aur Committed (.git repository mein stored).

git add kya karta hai?

Working directory se changes ko staging area mein stage karta hai, unhe next commit mein include karne ke liye mark karta hai.

Git mein commit kya hai?

Ek specific time pe project ka snapshot, ek SHA-1 hash se identify kiya gaya, jisme author info, timestamp, message, aur parent commit(s) ki taraf pointer hota hai.

Git mein branch kya hai?

Ek commit ki taraf ek movable pointer, jo development ki ek independent line represent karta hai. Sirf 41 bytes jo ek commit hash reference karti hai.

git fetch aur git pull mein kya difference hai? :: git fetch remote changes bina merge kiye download karta hai; git pull fetch + merge automatically karta hai.

.gitignore file kyun use karte hain?

Git ko auto-generated files, large datasets, secrets, aur environment-specific files track karne se rokne ke liye jo version control mein nahi honi chahiye.

git checkout -b feature-x kya karta hai?

"feature-x" naam ki ek nayi branch create karta hai aur ek command mein uspe switch karta hai (git branch + git checkout ka shorthand).

Merge commit kya hota hai?

Ek commit jiske do (ya zyada) parent commits hote hain, tab create hota hai jab aise branches merge ki jaati hain jo diverge ho gayi hों—dono branches ke changes combine karta hai.

Git mein HEAD kis taraf point karta hai?

Current branch reference ya commit jispe tum kaam kar rahe ho. Decide karta hai ki nayi commits kahan add hongi.

Feature branches kyun use karte hain?

Experimental kaam ko stable main branch se isolate karne ke liye, parallel development enable karte hue bina production code break kiye.

Commit messages ka kya purpose hai?

Document karna kya change hua aur kyun, history ko searchable banata hai aur future developers ko codebase ka evolution samajhne mein help karta hai.

Git commits efficiently kaise store karta hai?

Commits ke beech sirf differences (deltas) store karke, full file copies nahi, content-addressable storage use karke.

Fast-forward merge kya hota hai?

Jab target branch diverge nahi hui ho, Git simply branch pointer aage move karta hai merge commit create karne ki jagah.

git push origin main kya karta hai?

Local commits ko main branch se "origin" naam ke remote repository pe bhejtaa hai aur remote branch pointer update karta hai.

ML projects mein tags kyun useful hain?

Ye specific commits ko significant mark karte hain (e.g., production models), tag checkout karke ek model version ki exact reproduction enable karte hain.

Core Concepts

Files Ki Teen States

Essential Commands - Workflow Se Derived

1. Initializing aur Cloning

2. Basic Workflow Commands

3. Branching aur Merging

4. Remote Operations

Worked Examples

Common Mistakes

Git Workflow Patterns

ML Projects Ke Liye Best Practices

Connections

Concept Map