スマートアラームの技術：React Nativeでセンサーデータから睡眠サイクルへ

npm install react-native-sensors
npm install @tensorflow/tfjs @tensorflow/tfjs-react-native

cd ios && pod install && cd ..

// src/services/accelerometerService.js
import { accelerometer } from 'react-native-sensors';
import { map, filter } from 'rxjs/operators';

const MOVEMENT_THRESHOLD = 0.1; // Adjust this based on testing

export const startMovementDetection = (onMovement) => {
  const subscription = accelerometer
    .pipe(
      // We are interested in the magnitude of the acceleration vector
      map(({ x, y, z }) => Math.sqrt(x ** 2 + y ** 2 + z ** 2) - 9.8), // Subtract gravity
      // Filter out minor sensor noise
      filter(speed => speed > MOVEMENT_THRESHOLD)
    )
    .subscribe(
      speed => onMovement(speed),
      error => {
        console.log('The sensor is not available');
      }
    );

  return subscription;
};

// src/utils/signalProcessing.js

// A simple low-pass filter implementation
export class LowPassFilter {
  constructor(alpha) {
    this.alpha = alpha;
    this.lastValue = null;
  }

  filter(value) {
    if (this.lastValue === null) {
      this.lastValue = value;
      return value;
    }
    const filteredValue = this.alpha * value + (1 - this.alpha) * this.lastValue;
    this.lastValue = filteredValue;
    return filteredValue;
  }
}

// Function to manage data epochs
export const createEpochs = (data, epochDuration = 30000) => {
  const epochs = [];
  let currentEpoch = [];
  let epochStartTime = data.length > 0 ? data[0].timestamp : 0;

  data.forEach(point => {
    if (point.timestamp - epochStartTime < epochDuration) {
      currentEpoch.push(point.magnitude);
    } else {
      epochs.push(currentEpoch);
      currentEpoch = [point.magnitude];
      epochStartTime = point.timestamp;
    }
  });
  
  if (currentEpoch.length > 0) {
      epochs.push(currentEpoch);
  }

  return epochs;
};

// src/utils/featureExtraction.js

const calculateMean = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length || 0;

const calculateStdDev = (arr) => {
  const mean = calculateMean(arr);
  const variance = arr.reduce((a, b) => a + (b - mean) ** 2, 0) / arr.length || 0;
  return Math.sqrt(variance);
};

const countZeroCrossings = (arr) => {
  const mean = calculateMean(arr);
  let count = 0;
  for (let i = 1; i < arr.length; i++) {
    if ((arr[i-1] - mean) * (arr[i] - mean) < 0) {
      count++;
    }
  }
  return count;
};

export const extractFeatures = (epoch) => {
  if (epoch.length === 0) {
    return {
      mean: 0,
      stdDev: 0,
      zeroCrossings: 0,
      max: 0,
    };
  }

  return {
    mean: calculateMean(epoch),
    stdDev: calculateStdDev(epoch),
    zeroCrossings: countZeroCrossings(epoch),
    max: Math.max(...epoch),
  };
};

// src/services/sleepModelService.js
import * as tf from '@tensorflow/tfjs';
import '@tensorflow/tfjs-react-native';

let model = null;

// This is a mock model for demonstration.
// In a real application, you would load a pre-trained model.
const createMockModel = () => {
  const mockModel = tf.sequential();
  mockModel.add(tf.layers.dense({ units: 1, inputShape: [4] }));
  // Compile the model for execution
  mockModel.compile({ loss: 'meanSquaredError', optimizer: 'sgd' });
  return mockModel;
};

export const loadModel = async () => {
  if (model) return;
  try {
    // In a real app: await tf.loadLayersModel('path/to/your/model.json');
    await tf.ready();
    model = createMockModel();
    console.log('Mock model loaded successfully');
  } catch (error) {
    console.error('Failed to load the model', error);
  }
};

export const predictSleepStage = (features) => {
  if (!model) {
    console.warn('Model is not loaded yet.');
    return 'unknown';
  }

  const featureTensor = tf.tensor2d([[
    features.mean,
    features.stdDev,
    features.zeroCrossings,
    features.max,
  ]]);

  // In a real model, the output would be probabilities for each class
  // For this mock, we'll use a simple heuristic
  const movementScore = features.mean + features.stdDev;
  if (movementScore < 0.1) return 'deep';
  if (movementScore < 0.8) return 'light';
  return 'awake';
};

// App.js
import React, { useState, useEffect } from 'react';
import { View, Text, Button, StyleSheet } from 'react-native';
import { startMovementDetection } from './src/services/accelerometerService';
import { LowPassFilter, createEpochs } from './src/utils/signalProcessing';
import { extractFeatures } from './src/utils/featureExtraction';
import { loadModel, predictSleepStage } from './src/services/sleepModelService';

const EPOCH_DURATION = 30000; // 30 seconds

const App = () => {
  const [currentSleepStage, setCurrentSleepStage] = useState('unknown');
  const [isMonitoring, setIsMonitoring] = useState(false);
  const [movementData, setMovementData] = useState([]);

  useEffect(() => {
    loadModel();
  }, []);

  useEffect(() => {
    let subscription;
    if (isMonitoring) {
      const filter = new LowPassFilter(0.5);
      subscription = startMovementDetection(speed => {
        const filteredSpeed = filter.filter(speed);
        setMovementData(prevData => [
          ...prevData,
          { magnitude: filteredSpeed, timestamp: Date.now() },
        ]);
      });
    }

    return () => {
      if (subscription) {
        subscription.unsubscribe();
      }
    };
  }, [isMonitoring]);

  useEffect(() => {
    const interval = setInterval(() => {
      if (movementData.length === 0) return;
      
      const epochs = createEpochs(movementData);
      const lastEpoch = epochs[epochs.length - 1] || [];
      const features = extractFeatures(lastEpoch);
      const stage = predictSleepStage(features);
      setCurrentSleepStage(stage);

      // Simple alarm logic
      const now = new Date();
      const wakeUpHour = now.getHours();
      // Example: Wake up between 6:30 and 7:00 AM
      if (wakeUpHour >= 6 && now.getMinutes() >= 30 && wakeUpHour < 7) {
          if (stage === 'light') {
              console.log("WAKE UP! It's the perfect time.");
              setIsMonitoring(false);
              // Trigger actual alarm sound here
          }
      }

      // Clear old data to save memory
      setMovementData([]);

    }, EPOCH_DURATION);

    return () => clearInterval(interval);
  }, [movementData]);

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Smart Alarm</Text>
      <Text style={styles.status}>
        Monitoring: {isMonitoring ? 'On' : 'Off'}
      </Text>
      <Text style={styles.stage}>
        Current Sleep Stage: {currentSleepStage}
      </Text>
      <Button
        title={isMonitoring ? 'Stop Monitoring' : 'Start Monitoring'}
        onPress={() => setIsMonitoring(!isMonitoring)}
      />
    </View>
  );
};

// ... styles