Day 35: Capstone Project và Portfolio Building
Day 35: Capstone Project và Portfolio Building
🎯 Mục tiêu
- Hoàn thành dự án capstone end-to-end
- Xây dựng portfolio chuyên nghiệp
- Chuẩn bị cho sự nghiệp trong quantum computing
- Kết nối với cộng đồng lượng tử
- Tổng kết và đánh giá toàn bộ khóa học
🧠 Capstone Project - Tổng Quan
Tại sao cần Capstone Project?
- Tổng hợp kiến thức: Áp dụng tất cả kiến thức đã học
- Portfolio building: Tạo sản phẩm để showcase
- Real-world application: Giải quyết bài toán thực tế
- Career preparation: Chuẩn bị cho sự nghiệp
- Community contribution: Đóng góp cho cộng đồng
from qiskit import QuantumCircuit, Aer, execute, IBMQ
from qiskit.algorithms import VQE, QAOA
from qiskit.algorithms.optimizers import SPSA, COBYLA
from qiskit.quantum_info import Pauli
from qiskit.opflow import PauliSumOp, I, Z, X, Y
from qiskit.visualization import plot_histogram, plot_state_city
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import json
import pickle
from datetime import datetime
🚀 Capstone Project Options
1. Quantum Machine Learning Classifier
class QuantumMLClassifier:
"""
Quantum Machine Learning Classifier - Capstone Project
"""
def __init__(self, n_qubits=4, n_layers=2):
self.n_qubits = n_qubits
self.n_layers = n_layers
self.circuit = None
self.parameters = []
self.optimizer = SPSA(maxiter=100)
self.backend = Aer.get_backend('qasm_simulator')
def create_circuit(self):
"""
Tạo quantum circuit cho classification
"""
qc = QuantumCircuit(self.n_qubits, self.n_qubits)
# Parameters for feature encoding
feature_params = [Parameter(f'x_{i}') for i in range(self.n_qubits)]
# Parameters for variational layers
var_params = []
for layer in range(self.n_layers):
for i in range(self.n_qubits):
theta = Parameter(f'θ_{layer}_{i}')
var_params.append(theta)
# Feature encoding layer
for i in range(self.n_qubits):
qc.rx(feature_params[i], i)
qc.rz(feature_params[i], i)
# Variational layers
param_idx = 0
for layer in range(self.n_layers):
# Single-qubit rotations
for i in range(self.n_qubits):
qc.ry(var_params[param_idx], i)
param_idx += 1
# Entangling layer
for i in range(self.n_qubits - 1):
qc.cx(i, i + 1)
qc.cx(self.n_qubits - 1, 0)
# Measurement
qc.measure_all()
self.circuit = qc
self.parameters = feature_params + var_params
return qc
def prepare_data(self, n_samples=200):
"""
Chuẩn bị dữ liệu cho training
"""
# Generate synthetic data
X, y = make_classification(
n_samples=n_samples,
n_features=self.n_qubits,
n_redundant=0,
n_informative=self.n_qubits,
random_state=42,
n_clusters_per_class=1
)
# Normalize data
X = (X - X.mean(axis=0)) / X.std(axis=0)
# Split data
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
return X_train, X_test, y_train, y_test
def quantum_kernel(self, x1, x2):
"""
Tính quantum kernel giữa hai điểm dữ liệu
"""
# Create circuit with data
qc = self.circuit.bind_parameters({f'x_{i}': x1[i] for i in range(self.n_qubits)})
# Execute circuit
job = execute(qc, self.backend, shots=1000)
result = job.result()
counts1 = result.get_counts()
# Create circuit with second data point
qc2 = self.circuit.bind_parameters({f'x_{i}': x2[i] for i in range(self.n_qubits)})
job2 = execute(qc2, self.backend, shots=1000)
result2 = job2.result()
counts2 = result2.get_counts()
# Calculate kernel (simplified)
kernel_value = 0
for state in counts1:
if state in counts2:
kernel_value += (counts1[state] * counts2[state]) / (1000 * 1000)
return kernel_value
def train(self, X_train, y_train):
"""
Training quantum classifier
"""
print("Training Quantum ML Classifier...")
# Initialize parameters randomly
initial_params = np.random.random(len(self.parameters))
# Define objective function
def objective(params):
total_loss = 0
for i in range(len(X_train)):
# Bind parameters
param_dict = {}
for j, param in enumerate(self.parameters):
if param.name.startswith('x_'):
param_dict[param] = X_train[i][int(param.name.split('_')[1])]
else:
param_dict[param] = params[j - self.n_qubits]
# Execute circuit
qc_bound = self.circuit.bind_parameters(param_dict)
job = execute(qc_bound, self.backend, shots=100)
result = job.result()
counts = result.get_counts()
# Calculate prediction (simplified)
prediction = 0
for state, count in counts.items():
if state[0] == '1': # First qubit measurement
prediction += count / 100
# Calculate loss
loss = (prediction - y_train[i]) ** 2
total_loss += loss
return total_loss / len(X_train)
# Optimize
result = self.optimizer.minimize(objective, initial_params)
self.optimal_params = result.x
print(f"Training completed. Final loss: {result.fun:.4f}")
return result
def predict(self, X_test):
"""
Dự đoán trên test data
"""
predictions = []
for x in X_test:
# Bind parameters
param_dict = {}
for j, param in enumerate(self.parameters):
if param.name.startswith('x_'):
param_dict[param] = x[int(param.name.split('_')[1])]
else:
param_dict[param] = self.optimal_params[j - self.n_qubits]
# Execute circuit
qc_bound = self.circuit.bind_parameters(param_dict)
job = execute(qc_bound, self.backend, shots=100)
result = job.result()
counts = result.get_counts()
# Calculate prediction
prediction = 0
for state, count in counts.items():
if state[0] == '1':
prediction += count / 100
predictions.append(1 if prediction > 0.5 else 0)
return np.array(predictions)
def evaluate(self, X_test, y_test):
"""
Đánh giá model
"""
predictions = self.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
print(f"Test Accuracy: {accuracy:.4f}")
print("\nClassification Report:")
print(classification_report(y_test, predictions))
return accuracy, predictions
# Test Quantum ML Classifier
qml_classifier = QuantumMLClassifier(n_qubits=4, n_layers=2)
qml_classifier.create_circuit()
X_train, X_test, y_train, y_test = qml_classifier.prepare_data()
qml_classifier.train(X_train, y_train)
accuracy, predictions = qml_classifier.evaluate(X_test, y_test)
2. Quantum Chemistry Simulation
class QuantumChemistrySimulator:
"""
Quantum Chemistry Simulator - Capstone Project
"""
def __init__(self, molecule_name="H2"):
self.molecule_name = molecule_name
self.hamiltonian = None
self.ground_state_energy = None
self.vqe_result = None
def create_h2_hamiltonian(self):
"""
Tạo Hamiltonian cho phân tử H2
"""
# H2 molecule in minimal basis
# H = -0.2427*I - 0.1809*Z0 - 0.1809*Z1 + 0.1722*Z0Z1 + 0.0452*X0X1
hamiltonian = PauliSumOp.from_list([
('II', -0.2427),
('ZI', -0.1809),
('IZ', -0.1809),
('ZZ', 0.1722),
('XX', 0.0452)
])
self.hamiltonian = hamiltonian
return hamiltonian
def create_ansatz(self):
"""
Tạo ansatz circuit cho VQE
"""
qc = QuantumCircuit(2)
# Reference state |01⟩ (Hartree-Fock)
qc.x(0)
# UCC ansatz
theta = Parameter('θ')
qc.cx(0, 1)
qc.ry(theta, 1)
qc.cx(0, 1)
return qc, [theta]
def run_vqe(self):
"""
Chạy VQE để tìm ground state energy
"""
# Create ansatz
ansatz, params = self.create_ansatz()
# Setup VQE
optimizer = COBYLA(maxiter=100)
backend = Aer.get_backend('statevector_simulator')
vqe = VQE(
ansatz=ansatz,
optimizer=optimizer,
quantum_instance=backend
)
# Solve
result = vqe.solve(self.hamiltonian)
self.vqe_result = result
self.ground_state_energy = result.optimal_value
print(f"Ground State Energy: {result.optimal_value:.6f} Hartree")
print(f"Optimal Parameters: {result.optimal_parameters}")
return result
def analyze_results(self):
"""
Phân tích kết quả simulation
"""
if self.vqe_result is None:
print("Please run VQE first")
return
# Convert to eV
energy_ev = self.ground_state_energy * 27.2114 # Hartree to eV
print(f"\n=== {self.molecule_name} Analysis ===")
print(f"Ground State Energy: {self.ground_state_energy:.6f} Hartree")
print(f"Ground State Energy: {energy_ev:.4f} eV")
print(f"Optimal Parameters: {self.vqe_result.optimal_parameters}")
# Compare with exact result
exact_energy = -1.1373 # Hartree (exact for H2)
error = abs(self.ground_state_energy - exact_energy)
print(f"Exact Energy: {exact_energy:.6f} Hartree")
print(f"Error: {error:.6f} Hartree")
print(f"Relative Error: {error/abs(exact_energy)*100:.2f}%")
return {
'energy_hartree': self.ground_state_energy,
'energy_ev': energy_ev,
'error': error,
'relative_error': error/abs(exact_energy)*100
}
# Test Quantum Chemistry Simulator
chem_simulator = QuantumChemistrySimulator("H2")
chem_simulator.create_h2_hamiltonian()
vqe_result = chem_simulator.run_vqe()
analysis = chem_simulator.analyze_results()
3. Quantum Optimization Solver
class QuantumOptimizationSolver:
"""
Quantum Optimization Solver - Capstone Project
"""
def __init__(self, problem_type="maxcut"):
self.problem_type = problem_type
self.graph = None
self.cost_operator = None
self.qaoa_result = None
def create_maxcut_problem(self, n_nodes=4):
"""
Tạo bài toán MaxCut
"""
# Create simple graph
edges = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)]
self.graph = edges
# Create cost operator for MaxCut
cost_operator = PauliSumOp.from_list([
('ZZ', 1.0), # Edge (0,1)
('IZ', 1.0), # Edge (1,2)
('ZI', 1.0), # Edge (2,3)
('ZZ', 1.0), # Edge (3,0)
('ZZ', 1.0) # Edge (0,2)
])
self.cost_operator = cost_operator
return cost_operator
def run_qaoa(self, p=2):
"""
Chạy QAOA để giải bài toán optimization
"""
# Create QAOA
optimizer = COBYLA(maxiter=100)
backend = Aer.get_backend('qasm_simulator')
qaoa = QAOA(
optimizer=optimizer,
reps=p,
quantum_instance=backend
)
# Solve
result = qaoa.solve(self.cost_operator)
self.qaoa_result = result
print(f"Optimal Cost: {result.optimal_value:.4f}")
print(f"Optimal Parameters: {result.optimal_parameters}")
return result
def analyze_solution(self):
"""
Phân tích solution
"""
if self.qaoa_result is None:
print("Please run QAOA first")
return
# Get optimal circuit
optimal_circuit = self.qaoa_result.optimal_circuit
# Execute circuit to get solution
backend = Aer.get_backend('qasm_simulator')
job = execute(optimal_circuit, backend, shots=1000)
result = job.result()
counts = result.get_counts()
print(f"\n=== {self.problem_type.upper()} Solution ===")
print(f"Optimal Cost: {self.qaoa_result.optimal_value:.4f}")
print(f"Most frequent solutions:")
# Sort by frequency
sorted_counts = sorted(counts.items(), key=lambda x: x[1], reverse=True)
for i, (solution, count) in enumerate(sorted_counts[:5]):
probability = count / 1000
print(f" {solution}: {count} times ({probability:.2%})")
# Calculate cut value for this solution
cut_value = self.calculate_cut_value(solution)
print(f" Cut value: {cut_value}")
return counts
def calculate_cut_value(self, solution):
"""
Tính giá trị cut cho một solution
"""
cut_value = 0
for edge in self.graph:
node1, node2 = edge
if solution[node1] != solution[node2]:
cut_value += 1
return cut_value
# Test Quantum Optimization Solver
opt_solver = QuantumOptimizationSolver("maxcut")
opt_solver.create_maxcut_problem()
qaoa_result = opt_solver.run_qaoa()
solution_counts = opt_solver.analyze_solution()
📊 Portfolio Building
1. Project Documentation
class ProjectDocumentation:
"""
Tạo documentation cho capstone project
"""
def __init__(self, project_name):
self.project_name = project_name
self.documentation = {}
def create_readme(self):
"""
Tạo README.md cho project
"""
readme_content = f"""
# {self.project_name}
## Mô tả
Quantum computing project sử dụng Qiskit để giải quyết bài toán thực tế.
## Cài đặt
```bash
pip install qiskit numpy matplotlib scikit-learn
Sử dụng
# Import project
from {self.project_name.lower().replace(' ', '_')} import *
# Run project
python main.py
Kết quả
- Accuracy: {accuracy:.4f}
- Performance metrics được thể hiện trong notebook
Tác giả
[Your Name]
License
MIT “””
return readme_content
def create_requirements(self):
"""
Tạo requirements.txt
"""
requirements = """ qiskit>=0.40.0 numpy>=1.21.0 matplotlib>=3.5.0 scikit-learn>=1.0.0 pandas>=1.3.0 seaborn>=0.11.0 """
return requirements
def create_presentation(self):
"""
Tạo presentation slides
"""
slides_content = f""" # {self.project_name} - Presentation
Slide 1: Introduction
- Problem statement
- Quantum computing approach
- Expected outcomes
Slide 2: Methodology
- Quantum algorithm used
- Implementation details
- Technical challenges
Slide 3: Results
- Performance metrics
- Comparison with classical methods
- Key findings
Slide 4: Conclusion
- Summary of achievements
- Future work
- Impact and applications “”” return slides_content
Create documentation
doc = ProjectDocumentation(“Quantum ML Classifier”) readme = doc.create_readme() requirements = doc.create_requirements() presentation = doc.create_presentation()
### 2. GitHub Repository Setup
```python
def setup_github_repo():
"""
Hướng dẫn setup GitHub repository
"""
setup_instructions = """
# GitHub Repository Setup
## 1. Create Repository
- Go to GitHub.com
- Click "New repository"
- Name: quantum-ml-classifier
- Description: Quantum Machine Learning Classifier using Qiskit
- Make it public
- Add README.md
## 2. Clone Repository
```bash
git clone https://github.com/yourusername/quantum-ml-classifier.git
cd quantum-ml-classifier
3. Add Project Files
# Add all files
git add .
# Commit changes
git commit -m "Initial commit: Quantum ML Classifier"
# Push to GitHub
git push origin main
4. Repository Structure
quantum-ml-classifier/
├── README.md
├── requirements.txt
├── main.py
├── quantum_classifier.py
├── notebooks/
│ ├── 01_data_preparation.ipynb
│ ├── 02_model_training.ipynb
│ └── 03_results_analysis.ipynb
├── data/
├── results/
└── docs/
└── presentation.md
””” return setup_instructions
github_setup = setup_github_repo()
## 🎯 Career Preparation
### 1. Resume Building
```python
def create_quantum_resume():
"""
Tạo resume cho quantum computing career
"""
resume_content = """
# [Your Name] - Quantum Computing Engineer
## Contact
- Email: your.email@example.com
- LinkedIn: linkedin.com/in/yourprofile
- GitHub: github.com/yourusername
- Portfolio: yourportfolio.com
## Summary
Quantum computing engineer với 35 ngày intensive training về quantum algorithms,
Qiskit programming, và real hardware experience. Chuyên về quantum machine learning,
optimization, và quantum chemistry simulation.
## Skills
### Quantum Computing
- Qiskit, PennyLane, Cirq
- Quantum algorithms (Grover, Shor, QFT, VQE, QAOA)
- Quantum error correction và mitigation
- IBM Quantum Experience
### Programming
- Python, NumPy, SciPy
- Machine Learning (scikit-learn, TensorFlow)
- Data visualization (Matplotlib, Seaborn)
- Version control (Git, GitHub)
### Mathematics
- Linear algebra, quantum mechanics
- Optimization theory
- Statistical analysis
- Algorithm complexity
## Projects
### Quantum ML Classifier
- Developed quantum machine learning classifier using Qiskit
- Achieved 85% accuracy on synthetic dataset
- Implemented quantum feature maps và variational circuits
- Technologies: Qiskit, Python, scikit-learn
### Quantum Chemistry Simulator
- Built VQE-based molecular simulation for H2 molecule
- Achieved 99.5% accuracy compared to exact results
- Implemented UCC ansatz và optimization
- Technologies: Qiskit, VQE, quantum chemistry
### Quantum Optimization Solver
- Developed QAOA solver for MaxCut problems
- Optimized quantum circuits for NISQ devices
- Implemented error mitigation techniques
- Technologies: QAOA, NISQ optimization
## Education
- Quantum Mathematics Intensive Course (35 days)
- [Your University] - [Your Degree]
- Relevant coursework: Quantum Computing, Machine Learning, Optimization
## Certifications
- IBM Quantum Experience User
- Qiskit Developer Certification (if applicable)
## Languages
- English (Fluent)
- Vietnamese (Native)
"""
return resume_content
resume = create_quantum_resume()
2. Job Search Strategy
def quantum_job_search_strategy():
"""
Chiến lược tìm việc trong quantum computing
"""
strategy = """
# Quantum Computing Job Search Strategy
## 1. Target Companies
### Big Tech
- IBM Quantum
- Google Quantum AI
- Microsoft Quantum
- Amazon Braket
- Intel Quantum
### Quantum Startups
- Rigetti Computing
- IonQ
- PsiQuantum
- Xanadu
- Zapata Computing
### Research Institutions
- National Labs (Argonne, Oak Ridge)
- Universities with quantum programs
- Research organizations
## 2. Job Titles to Target
- Quantum Software Engineer
- Quantum Algorithm Developer
- Quantum Research Scientist
- Quantum Applications Engineer
- Quantum Computing Researcher
## 3. Skills to Highlight
- Qiskit programming experience
- Real hardware experience (IBM Quantum)
- Algorithm implementation
- Error mitigation techniques
- Portfolio projects
## 4. Networking
- LinkedIn quantum computing groups
- Quantum computing conferences
- Local quantum meetups
- Online quantum communities
## 5. Application Strategy
- Customize resume for each position
- Include portfolio links
- Highlight relevant projects
- Demonstrate quantum knowledge
"""
return strategy
job_strategy = quantum_job_search_strategy()
🌐 Community Engagement
1. Online Communities
def quantum_communities():
"""
Danh sách cộng đồng quantum computing
"""
communities = """
# Quantum Computing Communities
## Online Forums
- Quantum Computing Stack Exchange
- Reddit r/QuantumComputing
- Qiskit Community Forum
- PennyLane Community
## Social Media
- LinkedIn Quantum Computing Groups
- Twitter #QuantumComputing
- Discord Quantum Computing servers
- Telegram Quantum groups
## Conferences & Events
- Qiskit Global Summer School
- IBM Quantum Challenge
- Quantum Computing Hackathons
- Local quantum meetups
## Learning Platforms
- IBM Quantum Learning
- Qiskit Textbook
- Quantum Computing Report
- Quantum Journal
"""
return communities
communities_list = quantum_communities()
2. Contributing to Open Source
def open_source_contribution():
"""
Hướng dẫn đóng góp open source
"""
contribution_guide = """
# Open Source Contribution Guide
## 1. Qiskit Ecosystem
- Qiskit Terra: Core quantum circuits
- Qiskit Aer: Simulators
- Qiskit Ignis: Error mitigation
- Qiskit Aqua: Algorithms
## 2. Contribution Types
- Bug fixes
- Documentation improvements
- New features
- Tutorial creation
- Code examples
## 3. Getting Started
- Fork repository
- Create feature branch
- Make changes
- Write tests
- Submit pull request
## 4. Your Projects
- Open source your capstone projects
- Create quantum tutorials
- Share quantum notebooks
- Build quantum tools
"""
return contribution_guide
contribution_guide = open_source_contribution()
📈 Final Assessment
1. Skills Assessment
def final_skills_assessment():
"""
Đánh giá kỹ năng cuối khóa
"""
assessment = {
"Quantum Fundamentals": {
"Superposition": "✅ Mastered",
"Entanglement": "✅ Mastered",
"Measurement": "✅ Mastered",
"Quantum Gates": "✅ Mastered"
},
"Programming": {
"Qiskit": "✅ Proficient",
"Python": "✅ Proficient",
"Quantum Circuits": "✅ Proficient",
"Algorithm Implementation": "✅ Proficient"
},
"Algorithms": {
"Grover": "✅ Implemented",
"VQE": "✅ Implemented",
"QAOA": "✅ Implemented",
"QFT": "✅ Implemented"
},
"Real Hardware": {
"IBM Quantum": "✅ Experience",
"Error Mitigation": "✅ Implemented",
"Noise Characterization": "✅ Understanding",
"NISQ Optimization": "✅ Applied"
},
"Applications": {
"Quantum ML": "✅ Project Completed",
"Quantum Chemistry": "✅ Project Completed",
"Quantum Optimization": "✅ Project Completed",
"Portfolio": "✅ Created"
}
}
return assessment
skills_assessment = final_skills_assessment()
2. Learning Path Forward
def future_learning_path():
"""
Lộ trình học tập tiếp theo
"""
learning_path = """
# Future Learning Path
## Short Term (3-6 months)
- Deep dive into specific quantum algorithms
- Contribute to open source quantum projects
- Attend quantum computing conferences
- Build more complex quantum applications
## Medium Term (6-12 months)
- Specialize in quantum machine learning
- Learn additional quantum frameworks (PennyLane, Cirq)
- Work on quantum research projects
- Network with quantum computing professionals
## Long Term (1+ years)
- Pursue advanced quantum computing degree
- Work in quantum computing industry
- Contribute to quantum computing research
- Mentor others in quantum computing
## Specializations
- Quantum Machine Learning
- Quantum Chemistry
- Quantum Cryptography
- Quantum Error Correction
- Quantum Hardware
"""
return learning_path
future_path = future_learning_path()
🎯 Bài tập cuối khóa
Bài tập 1: Complete Capstone Project
def capstone_project_requirements():
"""
Yêu cầu cho capstone project hoàn chỉnh
"""
requirements = """
# Capstone Project Requirements
## 1. Project Selection
- Choose one: Quantum ML, Quantum Chemistry, or Quantum Optimization
- Define clear problem statement
- Set measurable objectives
## 2. Implementation
- Implement complete solution
- Use real quantum hardware when possible
- Apply error mitigation techniques
- Optimize for NISQ devices
## 3. Documentation
- Create comprehensive README
- Write technical documentation
- Create presentation slides
- Record demo video
## 4. Analysis
- Compare with classical methods
- Analyze performance metrics
- Discuss limitations and improvements
- Document lessons learned
## 5. Portfolio
- Host project on GitHub
- Create portfolio website
- Write blog post about project
- Share with quantum community
"""
return requirements
project_requirements = capstone_project_requirements()
Bài tập 2: Portfolio Website
def portfolio_website_structure():
"""
Cấu trúc website portfolio
"""
structure = """
# Portfolio Website Structure
## Pages
1. Home
- Introduction
- Key skills
- Contact information
2. Projects
- Quantum ML Classifier
- Quantum Chemistry Simulator
- Quantum Optimization Solver
- Other projects
3. Skills
- Quantum Computing
- Programming
- Mathematics
- Tools & Technologies
4. Experience
- Education
- Certifications
- Work experience
- Research
5. Blog
- Quantum computing articles
- Tutorial posts
- Project updates
- Industry insights
6. Contact
- Contact form
- Social media links
- Resume download
"""
return structure
website_structure = portfolio_website_structure()
📚 Tài nguyên bổ sung
Career Resources:
Portfolio Examples:
Networking:
🎯 Tổng kết khóa học
Thành tựu đạt được:
- ✅ Hoàn thành 35 ngày intensive quantum computing training
- ✅ Thành thạo Qiskit và quantum programming
- ✅ Triển khai các thuật toán lượng tử quan trọng
- ✅ Làm việc với real quantum hardware
- ✅ Hoàn thành capstone project
- ✅ Xây dựng portfolio chuyên nghiệp
Kỹ năng chuyên môn:
- Quantum algorithms (Grover, Shor, VQE, QAOA)
- Quantum machine learning và optimization
- Error mitigation và NISQ optimization
- Real hardware experience với IBM Quantum
- Project management và documentation
Chuẩn bị cho sự nghiệp:
- Portfolio hoàn chỉnh với projects thực tế
- Kết nối với cộng đồng quantum computing
- Chiến lược tìm việc và networking
- Lộ trình học tập tiếp theo
“The future of computing is quantum, and you are now part of that future.” 🚀