mirror of
https://github.com/MLSysBook/TinyTorch.git
synced 2026-07-22 05:06:53 -05:00
70 KiB
70 KiB
In [ ]:
#| default_exp core.setup
#| export
import sys
import platform
import psutil
import os
from typing import Dict, AnyIn [ ]:
print("🔥 TinyTorch Setup Module")
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")
print(f"Platform: {platform.system()}")
print("Ready to configure your TinyTorch installation!")In [ ]:
#| export
def personal_info() -> Dict[str, str]:
"""
Return personal information for this TinyTorch installation.
This function configures your personal TinyTorch installation with your identity.
It's the foundation of proper ML engineering practices - every system needs
to know who built it and how to contact them.
TODO: Implement personal information configuration.
STEP-BY-STEP IMPLEMENTATION:
1. Create a dictionary with your personal details
2. Include all required keys: developer, email, institution, system_name, version
3. Use your actual information (not placeholder text)
4. Make system_name unique and descriptive
5. Keep version as '1.0.0' for now
EXAMPLE OUTPUT:
{
'developer': 'Vijay Janapa Reddi',
'email': 'vj@eecs.harvard.edu',
'institution': 'Harvard University',
'system_name': 'VJ-TinyTorch-Dev',
'version': '1.0.0'
}
IMPLEMENTATION HINTS:
- Replace the example with your real information
- Use a descriptive system_name (e.g., 'YourName-TinyTorch-Dev')
- Keep email format valid (contains @ and domain)
- Make sure all values are strings
- Consider how this info will be used in debugging and collaboration
LEARNING CONNECTIONS:
- This is like the 'author' field in Git commits
- Similar to maintainer info in Docker images
- Parallels author info in Python packages
- Foundation for professional ML development
"""
### BEGIN SOLUTION
return {
'developer': 'Vijay Janapa Reddi',
'email': 'vj@eecs.harvard.edu',
'institution': 'Harvard University',
'system_name': 'VJ-TinyTorch-Dev',
'version': '1.0.0'
}
### END SOLUTIONIn [ ]:
#| export
def system_info() -> Dict[str, Any]:
"""
Query and return system information for this TinyTorch installation.
This function gathers crucial hardware and software information that affects
ML performance, compatibility, and debugging. It's the foundation of
hardware-aware ML systems.
TODO: Implement system information queries.
STEP-BY-STEP IMPLEMENTATION:
1. Get Python version using sys.version_info
2. Get platform using platform.system()
3. Get architecture using platform.machine()
4. Get CPU count using psutil.cpu_count()
5. Get memory using psutil.virtual_memory().total
6. Convert memory from bytes to GB (divide by 1024^3)
7. Return all information in a dictionary
EXAMPLE OUTPUT:
{
'python_version': '3.9.7',
'platform': 'Darwin',
'architecture': 'arm64',
'cpu_count': 8,
'memory_gb': 16.0
}
IMPLEMENTATION HINTS:
- Use f-string formatting for Python version: f"{major}.{minor}.{micro}"
- Memory conversion: bytes / (1024^3) = GB
- Round memory to 1 decimal place for readability
- Make sure data types are correct (strings for text, int for cpu_count, float for memory_gb)
LEARNING CONNECTIONS:
- This is like `torch.cuda.is_available()` in PyTorch
- Similar to system info in MLflow experiment tracking
- Parallels hardware detection in TensorFlow
- Foundation for performance optimization in ML systems
PERFORMANCE IMPLICATIONS:
- cpu_count affects parallel processing capabilities
- memory_gb determines maximum model and batch sizes
- platform affects file system and process management
- architecture influences numerical precision and optimization
"""
### BEGIN SOLUTION
# Get Python version
version_info = sys.version_info
python_version = f"{version_info.major}.{version_info.minor}.{version_info.micro}"
# Get platform information
platform_name = platform.system()
architecture = platform.machine()
# Get CPU information
cpu_count = psutil.cpu_count()
# Get memory information (convert bytes to GB)
memory_bytes = psutil.virtual_memory().total
memory_gb = round(memory_bytes / (1024**3), 1)
return {
'python_version': python_version,
'platform': platform_name,
'architecture': architecture,
'cpu_count': cpu_count,
'memory_gb': memory_gb
}
### END SOLUTIONIn [ ]:
# Test personal information configuration
print("🔬 Unit Test: Personal Information...")
# Test personal_info function
personal = personal_info()
# Test return type
assert isinstance(personal, dict), "personal_info should return a dictionary"
# Test required keys
required_keys = ['developer', 'email', 'institution', 'system_name', 'version']
for key in required_keys:
assert key in personal, f"Dictionary should have '{key}' key"
# Test non-empty values
for key, value in personal.items():
assert isinstance(value, str), f"Value for '{key}' should be a string"
assert len(value) > 0, f"Value for '{key}' cannot be empty"
# Test email format
assert '@' in personal['email'], "Email should contain @ symbol"
assert '.' in personal['email'], "Email should contain domain"
# Test version format
assert personal['version'] == '1.0.0', "Version should be '1.0.0'"
# Test system name (should be unique/personalized)
assert len(personal['system_name']) > 5, "System name should be descriptive"
print("✅ Personal info function tests passed!")
print(f"✅ TinyTorch configured for: {personal['developer']}")
print(f"✅ System: {personal['system_name']}")In [ ]:
# Test system information queries
print("🔬 Unit Test: System Information...")
# Test system_info function
sys_info = system_info()
# Test return type
assert isinstance(sys_info, dict), "system_info should return a dictionary"
# Test required keys
required_keys = ['python_version', 'platform', 'architecture', 'cpu_count', 'memory_gb']
for key in required_keys:
assert key in sys_info, f"Dictionary should have '{key}' key"
# Test data types
assert isinstance(sys_info['python_version'], str), "python_version should be string"
assert isinstance(sys_info['platform'], str), "platform should be string"
assert isinstance(sys_info['architecture'], str), "architecture should be string"
assert isinstance(sys_info['cpu_count'], int), "cpu_count should be integer"
assert isinstance(sys_info['memory_gb'], (int, float)), "memory_gb should be number"
# Test reasonable values
assert sys_info['cpu_count'] > 0, "CPU count should be positive"
assert sys_info['memory_gb'] > 0, "Memory should be positive"
assert len(sys_info['python_version']) > 0, "Python version should not be empty"
# Test that values are actually queried (not hardcoded)
actual_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
assert sys_info['python_version'] == actual_version, "Python version should match actual system"
print("✅ System info function tests passed!")
print(f"✅ Python: {sys_info['python_version']} on {sys_info['platform']}")
print(f"✅ Memory: {sys_info['memory_gb']} GB, CPUs: {sys_info['cpu_count']}")In [ ]:
def test_personal_info():
"""Test personal_info function implementation."""
print("🔬 Unit Test: Personal Information...")
# Test personal_info function
personal = personal_info()
# Test return type
assert isinstance(personal, dict), "personal_info should return a dictionary"
# Test required keys
required_keys = ['developer', 'email', 'institution', 'system_name', 'version']
for key in required_keys:
assert key in personal, f"Dictionary should have '{key}' key"
# Test non-empty values
for key, value in personal.items():
assert isinstance(value, str), f"Value for '{key}' should be a string"
assert len(value) > 0, f"Value for '{key}' cannot be empty"
# Test email format
assert '@' in personal['email'], "Email should contain @ symbol"
assert '.' in personal['email'], "Email should contain domain"
# Test version format
assert personal['version'] == '1.0.0', "Version should be '1.0.0'"
# Test system name (should be unique/personalized)
assert len(personal['system_name']) > 5, "System name should be descriptive"
print("✅ Personal info function tests passed!")
print(f"✅ TinyTorch configured for: {personal['developer']}")In [ ]:
def test_system_info():
"""Test system_info function implementation."""
print("🔬 Unit Test: System Information...")
# Test system_info function
sys_info = system_info()
# Test return type
assert isinstance(sys_info, dict), "system_info should return a dictionary"
# Test required keys
required_keys = ['python_version', 'platform', 'architecture', 'cpu_count', 'memory_gb']
for key in required_keys:
assert key in sys_info, f"Dictionary should have '{key}' key"
# Test data types
assert isinstance(sys_info['python_version'], str), "python_version should be string"
assert isinstance(sys_info['platform'], str), "platform should be string"
assert isinstance(sys_info['architecture'], str), "architecture should be string"
assert isinstance(sys_info['cpu_count'], int), "cpu_count should be integer"
assert isinstance(sys_info['memory_gb'], (int, float)), "memory_gb should be number"
# Test reasonable values
assert sys_info['cpu_count'] > 0, "CPU count should be positive"
assert sys_info['memory_gb'] > 0, "Memory should be positive"
assert len(sys_info['python_version']) > 0, "Python version should not be empty"
# Test that values are actually queried (not hardcoded)
actual_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
assert sys_info['python_version'] == actual_version, "Python version should match actual system"
print("✅ System info function tests passed!")
print(f"✅ Python: {sys_info['python_version']} on {sys_info['platform']}")In [ ]:
#| export
import importlib
import pkg_resources
from typing import Dict, List, Optional
def validate_environment() -> Dict[str, Any]:
"""
Validate ML development environment and check essential dependencies.
This function checks that your system has the necessary packages for ML development.
It's like a pre-flight check before you start building ML systems.
TODO: Implement environment validation.
STEP-BY-STEP IMPLEMENTATION:
1. Define list of essential ML packages to check
2. For each package, try to import it and get version
3. Track which packages are available vs missing
4. Calculate environment health score
5. Return comprehensive environment report
ESSENTIAL PACKAGES TO CHECK:
- numpy: Numerical computing foundation
- matplotlib: Visualization and plotting
- psutil: System monitoring
- jupyter: Interactive development
- nbdev: Package development
- pytest: Testing framework
IMPLEMENTATION HINTS:
- Use try/except to handle missing packages gracefully
- Use pkg_resources.get_distribution(package).version for versions
- Calculate health_score as (available_packages / total_packages) * 100
- Round health_score to 1 decimal place
"""
### BEGIN SOLUTION
essential_packages = [
'numpy', 'matplotlib', 'psutil', 'jupyter', 'nbdev', 'pytest'
]
available = {}
missing = []
for package in essential_packages:
try:
# Try to import the package
importlib.import_module(package)
# Get version information
version = pkg_resources.get_distribution(package).version
available[package] = version
except (ImportError, pkg_resources.DistributionNotFound):
missing.append(package)
# Calculate health score
total_packages = len(essential_packages)
available_packages = len(available)
health_score = round((available_packages / total_packages) * 100, 1)
return {
'available_packages': available,
'missing_packages': missing,
'health_score': health_score,
'total_checked': total_packages,
'status': 'healthy' if health_score >= 80 else 'needs_attention'
}
### END SOLUTIONIn [ ]:
#| export
import time
import random
def benchmark_performance() -> Dict[str, Any]:
"""
Benchmark system performance for ML workloads.
This function measures computational performance to help you understand
your system's capabilities and optimize your ML development workflow.
TODO: Implement performance benchmarking.
STEP-BY-STEP IMPLEMENTATION:
1. CPU Test: Time a computationally intensive operation
2. Memory Test: Time a memory-intensive operation
3. Calculate performance scores based on execution time
4. Determine overall system performance rating
5. Return comprehensive benchmark results
BENCHMARK TESTS:
- CPU: Nested loop calculation (computational intensity)
- Memory: Large list operations (memory bandwidth)
- Combined: Overall system performance score
IMPLEMENTATION HINTS:
- Use time.time() to measure execution time
- CPU test: nested loops with mathematical operations
- Memory test: large list creation and manipulation
- Lower execution time = better performance
- Calculate scores as inverse of time (e.g., 1/time * 1000)
"""
### BEGIN SOLUTION
benchmarks = {}
# CPU Performance Test
print("⚡ Running CPU benchmark...")
start_time = time.time()
# CPU-intensive calculation
result = 0
for i in range(100000):
result += i * i + i / 2
cpu_time = time.time() - start_time
benchmarks['cpu_time'] = round(cpu_time, 3)
benchmarks['cpu_score'] = round(1000 / cpu_time, 1)
# Memory Performance Test
print("🧠 Running memory benchmark...")
start_time = time.time()
# Memory-intensive operations
large_list = list(range(1000000))
large_list.reverse()
large_list.sort()
memory_time = time.time() - start_time
benchmarks['memory_time'] = round(memory_time, 3)
benchmarks['memory_score'] = round(1000 / memory_time, 1)
# Overall Performance Score
overall_score = round((benchmarks['cpu_score'] + benchmarks['memory_score']) / 2, 1)
benchmarks['overall_score'] = overall_score
# Performance Rating
if overall_score >= 80:
rating = 'excellent'
elif overall_score >= 60:
rating = 'good'
elif overall_score >= 40:
rating = 'fair'
else:
rating = 'needs_optimization'
benchmarks['performance_rating'] = rating
return benchmarks
### END SOLUTIONIn [ ]:
#| export
import subprocess
import json
from pathlib import Path
def setup_development_environment() -> Dict[str, Any]:
"""
Configure development environment for professional ML development.
This function sets up essential tools and configurations to make your
development workflow more efficient and professional.
TODO: Implement development environment setup.
STEP-BY-STEP IMPLEMENTATION:
1. Check if Git is installed and configured
2. Verify Jupyter installation and configuration
3. Check Python development tools
4. Configure any missing tools
5. Return setup status and recommendations
DEVELOPMENT TOOLS TO CHECK:
- Git: Version control system
- Jupyter: Interactive development
- Python tools: Code quality and formatting
IMPLEMENTATION HINTS:
- Use subprocess.run() to check tool availability
- Use try/except to handle missing tools gracefully
- Provide helpful recommendations for missing tools
- Focus on tools that improve ML development workflow
"""
### BEGIN SOLUTION
setup_status = {}
recommendations = []
# Check Git installation and configuration
try:
git_version = subprocess.run(['git', '--version'],
capture_output=True, text=True, check=True)
setup_status['git_installed'] = True
setup_status['git_version'] = git_version.stdout.strip()
# Check Git configuration
try:
git_name = subprocess.run(['git', 'config', 'user.name'],
capture_output=True, text=True, check=True)
git_email = subprocess.run(['git', 'config', 'user.email'],
capture_output=True, text=True, check=True)
setup_status['git_configured'] = True
setup_status['git_name'] = git_name.stdout.strip()
setup_status['git_email'] = git_email.stdout.strip()
except subprocess.CalledProcessError:
setup_status['git_configured'] = False
recommendations.append("Configure Git: git config --global user.name 'Your Name'")
recommendations.append("Configure Git: git config --global user.email 'your.email@domain.com'")
except (subprocess.CalledProcessError, FileNotFoundError):
setup_status['git_installed'] = False
recommendations.append("Install Git: https://git-scm.com/downloads")
# Check Jupyter installation
try:
jupyter_version = subprocess.run(['jupyter', '--version'],
capture_output=True, text=True, check=True)
setup_status['jupyter_installed'] = True
setup_status['jupyter_version'] = jupyter_version.stdout.strip()
except (subprocess.CalledProcessError, FileNotFoundError):
setup_status['jupyter_installed'] = False
recommendations.append("Install Jupyter: pip install jupyter")
# Check Python tools
python_tools = ['pip', 'python']
for tool in python_tools:
try:
tool_version = subprocess.run([tool, '--version'],
capture_output=True, text=True, check=True)
setup_status[f'{tool}_installed'] = True
setup_status[f'{tool}_version'] = tool_version.stdout.strip()
except (subprocess.CalledProcessError, FileNotFoundError):
setup_status[f'{tool}_installed'] = False
recommendations.append(f"Install {tool}: Check Python installation")
# Calculate setup health
total_tools = 4 # git, jupyter, pip, python
installed_tools = sum([
setup_status.get('git_installed', False),
setup_status.get('jupyter_installed', False),
setup_status.get('pip_installed', False),
setup_status.get('python_installed', False)
])
setup_score = round((installed_tools / total_tools) * 100, 1)
return {
'setup_status': setup_status,
'recommendations': recommendations,
'setup_score': setup_score,
'status': 'ready' if setup_score >= 75 else 'needs_configuration'
}
### END SOLUTIONIn [ ]:
#| export
from datetime import datetime
def generate_system_report() -> Dict[str, Any]:
"""
Generate comprehensive system report for ML development.
This function combines all configuration and diagnostic information
into a single, actionable report for your ML development environment.
TODO: Implement comprehensive system reporting.
STEP-BY-STEP IMPLEMENTATION:
1. Gather personal information
2. Collect system information
3. Validate environment
4. Run performance benchmarks
5. Check development setup
6. Generate overall health score
7. Create comprehensive report with recommendations
REPORT SECTIONS:
- Personal configuration
- System specifications
- Environment validation
- Performance benchmarks
- Development setup
- Overall health assessment
- Recommendations for improvement
IMPLEMENTATION HINTS:
- Call all previously implemented functions
- Combine results into comprehensive report
- Calculate overall health score from all components
- Provide actionable recommendations
"""
### BEGIN SOLUTION
print("📊 Generating comprehensive system report...")
# Gather all information
personal = personal_info()
system = system_info()
environment = validate_environment()
performance = benchmark_performance()
development = setup_development_environment()
# Calculate overall health score (normalize performance score to 0-100 range)
normalized_performance = min(performance['overall_score'], 100) # Cap at 100
health_components = [
environment['health_score'],
normalized_performance,
development['setup_score']
]
overall_health = round(sum(health_components) / len(health_components), 1)
# Generate status
if overall_health >= 85:
status = 'excellent'
elif overall_health >= 70:
status = 'good'
elif overall_health >= 50:
status = 'fair'
else:
status = 'needs_attention'
# Compile recommendations
recommendations = []
if environment['health_score'] < 80:
recommendations.extend([f"Install missing package: {pkg}" for pkg in environment['missing_packages']])
if performance['overall_score'] < 50:
recommendations.append("Consider hardware upgrade for better ML performance")
recommendations.extend(development['recommendations'])
# Create comprehensive report
report = {
'timestamp': datetime.now().isoformat(),
'personal_info': personal,
'system_info': system,
'environment_validation': environment,
'performance_benchmarks': performance,
'development_setup': development,
'overall_health': overall_health,
'status': status,
'recommendations': recommendations,
'report_version': '1.0.0'
}
return report
### END SOLUTIONIn [ ]:
def test_performance_benchmark():
"""Test performance benchmarking function."""
print("🔬 Unit Test: Performance Benchmarking...")
benchmark_report = benchmark_performance()
# Test return type and structure
assert isinstance(benchmark_report, dict), "benchmark_performance should return a dictionary"
# Test required keys
required_keys = ['cpu_time', 'cpu_score', 'memory_time', 'memory_score', 'overall_score', 'performance_rating']
for key in required_keys:
assert key in benchmark_report, f"Report should have '{key}' key"
# Test data types
assert isinstance(benchmark_report['cpu_time'], (int, float)), "cpu_time should be number"
assert isinstance(benchmark_report['cpu_score'], (int, float)), "cpu_score should be number"
assert isinstance(benchmark_report['memory_time'], (int, float)), "memory_time should be number"
assert isinstance(benchmark_report['memory_score'], (int, float)), "memory_score should be number"
assert isinstance(benchmark_report['overall_score'], (int, float)), "overall_score should be number"
assert isinstance(benchmark_report['performance_rating'], str), "performance_rating should be string"
# Test reasonable values
assert benchmark_report['cpu_time'] > 0, "cpu_time should be positive"
assert benchmark_report['memory_time'] > 0, "memory_time should be positive"
assert benchmark_report['cpu_score'] > 0, "cpu_score should be positive"
assert benchmark_report['memory_score'] > 0, "memory_score should be positive"
assert benchmark_report['overall_score'] > 0, "overall_score should be positive"
valid_ratings = ['excellent', 'good', 'fair', 'needs_optimization']
assert benchmark_report['performance_rating'] in valid_ratings, "performance_rating should be valid"
print("✅ Performance benchmark tests passed!")
print(f"✅ Performance rating: {benchmark_report['performance_rating']}")In [ ]:
def test_development_setup():
"""Test development environment setup function."""
print("🔬 Unit Test: Development Environment Setup...")
setup_report = setup_development_environment()
# Test return type and structure
assert isinstance(setup_report, dict), "setup_development_environment should return a dictionary"
# Test required keys
required_keys = ['setup_status', 'recommendations', 'setup_score', 'status']
for key in required_keys:
assert key in setup_report, f"Report should have '{key}' key"
# Test data types
assert isinstance(setup_report['setup_status'], dict), "setup_status should be dict"
assert isinstance(setup_report['recommendations'], list), "recommendations should be list"
assert isinstance(setup_report['setup_score'], (int, float)), "setup_score should be number"
assert isinstance(setup_report['status'], str), "status should be string"
# Test reasonable values
assert 0 <= setup_report['setup_score'] <= 100, "setup_score should be between 0 and 100"
assert setup_report['status'] in ['ready', 'needs_configuration'], "status should be valid"
print("✅ Development setup tests passed!")
print(f"✅ Setup score: {setup_report['setup_score']}%")In [ ]:
def test_system_report():
"""Test comprehensive system report function."""
print("🔬 Unit Test: System Report Generation...")
report = generate_system_report()
# Test return type and structure
assert isinstance(report, dict), "generate_system_report should return a dictionary"
# Test required keys
required_keys = ['timestamp', 'personal_info', 'system_info', 'environment_validation',
'performance_benchmarks', 'development_setup', 'overall_health',
'status', 'recommendations', 'report_version']
for key in required_keys:
assert key in report, f"Report should have '{key}' key"
# Test data types
assert isinstance(report['timestamp'], str), "timestamp should be string"
assert isinstance(report['personal_info'], dict), "personal_info should be dict"
assert isinstance(report['system_info'], dict), "system_info should be dict"
assert isinstance(report['environment_validation'], dict), "environment_validation should be dict"
assert isinstance(report['performance_benchmarks'], dict), "performance_benchmarks should be dict"
assert isinstance(report['development_setup'], dict), "development_setup should be dict"
assert isinstance(report['overall_health'], (int, float)), "overall_health should be number"
assert isinstance(report['status'], str), "status should be string"
assert isinstance(report['recommendations'], list), "recommendations should be list"
assert isinstance(report['report_version'], str), "report_version should be string"
# Test reasonable values
assert 0 <= report['overall_health'] <= 100, "overall_health should be between 0 and 100"
valid_statuses = ['excellent', 'good', 'fair', 'needs_attention']
assert report['status'] in valid_statuses, "status should be valid"
print("✅ System report tests passed!")
print(f"✅ Overall system health: {report['overall_health']}%")
In [ ]:
def test_personal_info():
"""Test personal information function comprehensively."""
personal = personal_info()
assert isinstance(personal, dict), "personal_info should return a dictionary"
assert 'developer' in personal, "Dictionary should have 'developer' key"
assert '@' in personal['email'], "Email should contain @ symbol"
print("✅ Personal information function works")
def test_system_info():
"""Test system information function comprehensively."""
system = system_info()
assert isinstance(system, dict), "system_info should return a dictionary"
assert 'python_version' in system, "Dictionary should have 'python_version' key"
assert system['memory_gb'] > 0, "Memory should be positive"
print("✅ System information function works")
def test_environment_validation():
"""Test environment validation function comprehensively."""
env = validate_environment()
assert isinstance(env, dict), "validate_environment should return a dictionary"
assert 'health_score' in env, "Dictionary should have 'health_score' key"
print("✅ Environment validation function works")
def test_performance_benchmark():
"""Test performance benchmarking function comprehensively."""
perf = benchmark_performance()
assert isinstance(perf, dict), "benchmark_performance should return a dictionary"
assert 'cpu_score' in perf, "Dictionary should have 'cpu_score' key"
print("✅ Performance benchmarking function works")
def test_development_setup():
"""Test development setup function comprehensively."""
dev = setup_development_environment()
assert isinstance(dev, dict), "setup_development_environment should return a dictionary"
assert 'setup_score' in dev, "Dictionary should have 'setup_score' key"
print("✅ Development setup function works")
def test_system_report():
"""Test system report comprehensive function."""
report = generate_system_report()
assert isinstance(report, dict), "generate_system_report should return a dictionary"
assert 'overall_health' in report, "Dictionary should have 'overall_health' key"
print("✅ System report function works")In [ ]:
# =============================================================================
# STANDARDIZED MODULE TESTING - DO NOT MODIFY
# This cell is locked to ensure consistent testing across all TinyTorch modules
# =============================================================================
if __name__ == "__main__":
from tito.tools.testing import run_module_tests_auto
# Automatically discover and run all tests in this module
success = run_module_tests_auto("Setup")