Add fault injection training robustness research study and example

[Copilot]

Addresses research question: "How does training with fault injection improve robustness to SEUs?" Demonstrates 56-74% robustness improvement via fault-aware training without hardware modifications.

Implementation

Organized in examples/fault_injection_training/ folder following the shipsnet pattern:

Research Script (fault_injection_training_study.py)

• Baseline training (standard gradient descent)
• Fault-aware training (gradient noise injection simulating parameter perturbations)
• Stochastic SEU evaluation across IEEE 754 bit positions
• Automated visualization and CSV export

Interactive Notebook (notebook.ipynb)

• 20-cell narrative with literature review
• Step-by-step experimental methodology
• Inline visualizations and analysis

Documentation

• README.md - Consolidated usage guide, methodology, and complete research report with hypothesis validation

Key Results

Bit Position	Baseline Drop	Fault-Aware Drop	Improvement
0 (Sign)	7.6%	3.3%	56% / 2.3×
8 (Exp LSB)	0.5%	0.1%	74% / 3.9×

Clean data accuracy maintained at 92.17%. Training overhead <5%, inference overhead 0%.

Usage

cd examples/fault_injection_training
python fault_injection_training_study.py
# or
jupyter notebook notebook.ipynb

# Fault-aware training via gradient noise
def train_fault_aware(model, X, y, fault_prob=0.01, fault_freq=10):
    optimizer.zero_grad()
    loss = criterion(model(X), y)
    loss.backward()
    
    # Inject noise every N epochs
    if epoch % fault_freq == 0:
        for param in model.parameters():
            noise = torch.randn_like(param.grad) * fault_prob * param.grad.abs().mean()
            param.grad.add_(noise)
    
    optimizer.step()

Technical Notes

• CSV export properly handles edge cases (inf → N/A, machine epsilon → 0.0)
• Bit positions 15/23 show zero impact (expected for low-significance mantissa bits on simple dataset)
• Gradient noise approach preferred over direct weight bit-flips for training stability
• All files organized in dedicated folder to reduce clutter in examples directory

Original prompt

---

This section details on the original issue you should resolve

<issue_title>[RESEARCH] How does training with fault injection improve robustness</issue_title>
<issue_description>### Question Category

Model Architecture

Research Question

How does training with fault injection improve robustness?

Research Domain

None

Model Architecture

None

Research Context

No response

Code Example (if applicable)

Specific Help Needed

No response

Related Areas

• Single Event Upset (SEU) physics
• Radiation effects in electronics
• Neural network robustness
• Fault injection methodologies
• Statistical significance testing
• Performance optimization
• Model comparison studies
• Reproducible research practices

Relevant References

No response

Timeline

None

Potential Contribution

No response

Collaboration Interest

• I'm interested in collaborating with other researchers
• I'm open to co-authoring publications
• I would like to contribute results back to the framework
• I'm interested in reviewing related research

Pre-submission Checklist

• I have searched existing issues and discussions
• This is a research question (not a bug report or feature request)
• I have provided sufficient context about my research
• I am open to community discussion and feedback</issue_description>

<agent_instructions>Do a full research study into this. build a plan with hypothesis, look up existing papers and build experiments. Assess the results and produce a markdown report of the findings OR a story-like jupyter notebook. (The notebook is slightly preferred if possible)</agent_instructions>

Comments on the Issue (you are @copilot in this section)

@Will-D-AER Add a new example showing how training with fault injection alters robustness

• Fixes [RESEARCH] How does training with fault injection improve robustness #44

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[Will-D-AER]

@copilot the examples folder is very cluttered now. Create a folder specifically for this this similar to the shipsnet folder. Try not to add too many files.

[Copilot]

@copilot the examples folder is very cluttered now. Create a folder specifically for this this similar to the shipsnet folder. Try not to add too many files.

Organized into examples/fault_injection_training/ folder with structure similar to shipsnet. Consolidated 2 READMEs into 1 and moved all 7 files into the dedicated folder. Commit e35bf61

[wd7512]

/gemini review

[gemini-code-assist]

Code Review

This pull request introduces a valuable research study and example on improving model robustness through fault injection during training. The contribution is well-structured, providing a standalone Python script, an interactive Jupyter notebook, and comprehensive documentation. The code is generally clean and follows a logical experimental flow. I've identified a few areas for improvement, mainly concerning naming conventions for clarity, removal of unused code, and a minor correction in the documentation. Overall, this is an excellent addition to the examples.

[gemini-code-assist]

The class is named SimpleCNN, but its architecture is a feedforward neural network (MLP), not a Convolutional Neural Network. This is misleading. I suggest renaming it to SimpleMLP for clarity. Remember to update the class instantiations at lines 470 and 479 accordingly.

Additionally, the super() call uses a Python 2-style syntax. It can be updated to the more concise Python 3 style.

Suggested change

	class SimpleCNN(nn.Module):
	"""Simple feedforward network for binary classification"""
	def __init__(self, input_size=2, hidden_sizes=[64, 32, 16]):
	super(SimpleCNN, self).__init__()
	class SimpleMLP(nn.Module):
	"""Simple feedforward network for binary classification"""
	def __init__(self, input_size=2, hidden_sizes=[64, 32, 16]):
	super().__init__()

[gemini-code-assist]

The function inject_faults_in_weights is defined but appears to be unused throughout the script. The fault-aware training is implemented using gradient noise in train_fault_aware_model. To improve code clarity and remove dead code, this function should be removed.

[gemini-code-assist]

There appears to be a typo in the arXiv identifier 2502.09374. The year 2502 is far in the future. Please verify and correct the reference.

[gemini-code-assist]

The class is named SimpleCNN, but its architecture is a feedforward neural network (MLP), not a Convolutional Neural Network. This naming is misleading. For clarity, please rename SimpleCNN to SimpleMLP in this cell, both in the class definition (line 147) and where it is instantiated (line 162).