##  Eligibility

- Open to **all students** of NIT Jalandhar
- Participants have to compete **individually**

---

## Code of Conduct

### Academic Integrity
- All submissions must be your **original work**
- You may use online resources for learning, but **copying solutions is strictly prohibited**
- Discussion of approaches and techniques is encouraged, but **sharing code or predictions is not allowed**
- Use of baseline code provided by organizers is permitted and encouraged

### Collaboration Guidelines
- **Within Teams**: Full collaboration is allowed among team members
- **Between Teams**: You may discuss general approaches, algorithms, and techniques, but not share actual code, predictions, or specific implementations
- **Discussion Forum**: Be helpful and respectful. Guide others toward solutions without providing direct answers

### Fair Play
- Do not create multiple accounts to bypass submission limits
- Do not attempt to reverse-engineer or access the test solutions
- Do not use test set information during model training (data leakage)
- Report any suspicious activity or rule violations to organizers

### Respectful Behavior
- Be courteous and professional in all communications
- Respect other participants and organizers
- Provide constructive feedback when helping others
- No harassment, discrimination, or offensive behavior will be tolerated

---

##  Winner Selection & Evaluation

### Three-Component Evaluation Process

#### Component 1: Kaggle Leaderboard Performance (70%)
- Based on **private leaderboard score** (60% of test set)
- Uses the custom weighted evaluation metric
- Top 10 teams from private leaderboard advance to final evaluation

#### Component 2: Streamlit Deployment (30%)
- All top 10 teams must deploy a **functional Streamlit web application**
- The app should allow users to input feature values and get relationship probability predictions
- Deployment must be live and accessible via a public URL

**Streamlit Evaluation Criteria:**
- **Functionality (40%)**: App works correctly and produces accurate predictions
- **User Interface (30%)**: Clean, intuitive, and professional design
- **Features (20%)**: Input validation, visualizations, explanations
- **Code Quality (10%)**: Well-structured Streamlit code

#### Component 3: Code Review & GitHub Repository
Top 10 teams must submit their complete solution within **48 hours** of competition end:

**Required Submissions:**
1. **GitHub Repository Link** (mandatory for all participants)
2. **Streamlit App Deployment Link** (for top 10 teams)
3. **Complete Training Code** (Jupyter Notebook)
4. **Streamlit Application Code** (app.py)
5. **Requirements.txt** or environment.yml
6. **README.md** explaining your approach and deployment

**GitHub Repository Structure:**
```
your-repo-name/
├── notebooks/
│   └── train.ipynb (or train.py)
├── streamlit/
│   ├── app.py
│   └── utils.py (optional)
├── models/
│   └── trained_model.pkl (or .joblib, .h5, etc.)
├── data/
│   └── feature_lookup.csv (if needed by app)
├── requirements.txt
└── README.md
```

**Code Evaluation Criteria:**

✅ **Reproducibility (30%)**
   - Code runs successfully and generates submitted predictions
   - Clear instructions for environment setup
   - All dependencies properly documented

✅ **Originality (30%)**
   - Code will be checked against **AI-generated code** using detection tools
   - Code will be checked for **plagiarism** using automated systems
   - Solutions must demonstrate original thinking and implementation

✅ **Code Quality (20%)**
   - Clean, well-structured code
   - Proper comments and documentation
   - Efficient implementation

✅ **Approach Documentation (20%)**
   - Clear explanation of methodology
   - Feature engineering techniques described
   - Model selection reasoning explained

---

## Automatic Disqualification

You will be **immediately disqualified** if:

- ❌ Code fails plagiarism check (>70% similarity with other submissions)
- ❌ Code is predominantly AI-generated without proper modification/understanding
- ❌ Code cannot reproduce submitted predictions
- ❌ Evidence of data leakage or test set usage during training
- ❌ Use of external datasets not provided by organizers
- ❌ Multiple accounts detected
- ❌ Sharing of predictions or code between teams
- ❌ Failure to submit GitHub repository link
- ❌ Failure to deploy Streamlit app (for top 10 teams)
- ❌ Streamlit app is non-functional or produces incorrect predictions
- ❌ GitHub repository is private or inaccessible
- ❌ Violation of code of conduct

---

## Streamlit Deployment Requirements

### Mandatory for Top 10 Teams

All top 10 teams from the private leaderboard **must deploy a Streamlit application**.

### Deployment Platforms (Choose One)
- Streamlit Community Cloud (Recommended - Free)
- Hugging Face Spaces
- Render
- Railway
- Any other public hosting platform

### Minimum App Features

Your Streamlit app must include:

 **Input Form**: Allow users to input all 33 features (F1-F33)
- Provide appropriate input widgets (sliders, dropdowns, number inputs)
- Display feature names from feature_lookup.csv for clarity
- Include input validation

**Prediction Output**: Display the predicted relationship probability (0-100)

 **Visualization**: At least one of the following:
- Feature importance chart
- Prediction confidence visualization
- Input feature distribution comparison

 **About Section**: Brief description of your model and approach

## GitHub Repository Requirements

### Mandatory for ALL Participants

**Every participant/team must submit a GitHub repository link containing:**

1. **Training Notebook** (`notebooks/train.ipynb`)
   - Complete data preprocessing steps
   - Model training and evaluation
   - Clear markdown explanations

2. **Streamlit Code** (`streamlit/app.py`) - Required for top 10 only
   - Clean, modular code
   - Proper error handling
   - Loading of trained model

3. **Trained Model** (`models/`)
   - Saved model file(s)
   - Model should be loadable and reproducible

4. **Dependencies** (`requirements.txt`)
   - All libraries with versions
   - Should allow easy environment recreation

5. **README.md** - Must include:
   - Team name and member names with enrollment numbers
   - Problem approach summary (300-500 words)
   - Model description and architecture
   - How to run training notebook
   - How to run Streamlit app locally
   - Streamlit deployment link (for top 10)
   - Final Kaggle score achieved
   - Any special instructions

### GitHub Submission Process

1. Create a **public repository** on GitHub
2. Organize code according to the required structure
3. Ensure repository is accessible (public, not private)
4. Submit repository link via [submission form/email]
5. Repository must remain public until winner announcement

### Example README Template

```markdown
# Relationship Status Prediction - Team [Name]

## Approach Summary
[Brief description of your solution...]

## Model Details
- **Algorithm**: XGBoost, Random Forest, etc.
- **Key Features**: Feature engineering techniques used
- **Training Time**: ~X minutes

## Results
- **Private Leaderboard Score**: XX.XX
- **Public Leaderboard Score**: XX.XX

## Setup Instructions
```bash
pip install -r requirements.txt
```

## Running Training Notebook
```bash
jupyter notebook notebooks/train.ipynb
```

## Running Streamlit App Locally
```bash
streamlit run streamlit/app.py
```

## Streamlit Deployment
 Live App: [Your Streamlit URL]

---
- Code must be **well-commented**
- Variable names must be **meaningful** (not just `a`, `b`, `c`)
- Code structure must be **logical and organized**
- No hardcoded paths (use relative paths)
- Include error handling where appropriate

---

## AI & Plagiarism Detection

### What We Check
1. **AI-Generated Code Detection**
   - Your code will be analyzed using AI detection tools
   - High AI-detection scores (>80%) will trigger manual review
   - You must demonstrate understanding of your code in potential interviews

2. **Plagiarism Detection**
   - Code similarity checked against:
     - Other competition submissions
     - Public GitHub repositories
     - Kaggle kernels and notebooks
     - Online tutorials and courses
   - Similarity >70% will result in disqualification

3. **Manual Code Review**
   - Organizers reserve the right to interview top teams
   - You must be able to explain your code and approach
   - Cannot explain = assumed violation

### What's Acceptable
✅ Using scikit-learn, XGBoost, and other standard libraries  
✅ Adapting official documentation examples  
✅ Using the provided baseline code as a starting point  
✅ Using AI tools to debug or understand concepts (not to write entire solutions)  
✅ Referencing research papers and implementing techniques yourself

### What's NOT Acceptable
❌ Copying entire solutions from Kaggle/GitHub  
❌ Having AI write your entire solution without understanding  
❌ Copy-pasting code from teammates' previous work in other competitions  
❌ Using paid services to solve the problem for you  
❌ Submitting code you don't understand

---

## Final Scoring Formula

```
Final Score = (Kaggle Private Leaderboard Score × 0.70) + (Streamlit Evaluation Score × 0.30)
```

**Breakdown:**
- **Kaggle Score (70%)**: Based on prediction accuracy using custom metric
- **Streamlit Score (30%)**: Based on deployment evaluation rubric (100 points total)
  - Functionality: 40 points
  - User Interface: 30 points
  - Features & Innovation: 20 points
  - Code Quality: 10 points

**Note**: Streamlit evaluation only applies to **top 10 teams** from private leaderboard. Teams not in top 10 are ranked by Kaggle score only.

### Winner Selection
- Top 3 teams with **highest combined final scores** win
- In case of tie, Kaggle leaderboard score takes precedence
- All decisions by organizing committee are final

---

## Important Deadlines

| Milestone | Deadline |
|-----------|----------|
| Competition Opens | [TBD] |
| Kaggle Submission Deadline | [TBD] |
| GitHub Repository Submission (ALL participants) | 24 hours after competition end |
| Streamlit Deployment (Top 10 only) | 48 hours after competition end |
| Winner Announcement | [TBD] |

**Late submissions will not be accepted under any circumstances.**

---

## Support & Clarifications

- **Technical Issues**: [support-email@example.com]
- **GitHub Submission**: [submissions@example.com]
- **Streamlit Deployment Help**: [streamlit-help@example.com]
- **Report Violations**: [report@example.com] (confidential)

---

## Participant Agreement

By participating in this competition, you agree to:

1. Abide by all rules and guidelines stated above
2. Submit original work and properly cite any external resources
3. Submit GitHub repository link (mandatory for all participants)
4. Deploy Streamlit app if selected in top 10
5. Participate in code review/interview if requested
6. Keep GitHub repository public until winner announcement
7. Maintain Streamlit app live for evaluation period
8. Accept organizers' decisions as final
9. Allow organizers to verify your submission's authenticity

**Violation of these rules will result in immediate disqualification and may affect future participation eligibility.**

---

*Organized by Google Developer Groups on Campus (GDGC), NIT Jalandhar*

**Questions?** Reach out in the discussion forum or contact the organizing team.

**Good luck and happy learning! 🚀**