इस पेज का अनुवाद Cloud Translation API से किया गया है.

Cloud Run, Video Intelligence API, और Vertex AI का इस्तेमाल करके, वीडियो के अलग-अलग सीन की इमेज के बारे में जानकारी देने वाली सेवा बनाएं

1. परिचय

खास जानकारी

इस कोडलैब में, आपको Node.js पर Cloud Run सेवा बनानी होगी. यह सेवा वीडियो के हर सीन की विज़ुअल जानकारी देगी. सबसे पहले, आपकी सेवा किसी सीन के बदलने पर टाइमस्टैंप का पता लगाने के लिए, Video Intelligence API का इस्तेमाल करेगी. इसके बाद, आपकी सेवा हर सीन में बदलाव के टाइमस्टैंप का स्क्रीनशॉट लेने के लिए, ffmpeg नाम की तीसरे पक्ष की बाइनरी का इस्तेमाल करेगी. आखिर में, स्क्रीनशॉट की विज़ुअल जानकारी देने के लिए, Vertex AI की विज़ुअल कैप्शनिंग की सुविधा का इस्तेमाल किया जाता है.

इस कोडलैब से यह भी पता चलता है कि किसी दिए गए टाइमस्टैंप पर वीडियो से इमेज कैप्चर करने के लिए, Cloud Run सेवा में ffmpeg को कैसे इस्तेमाल किया जा सकता है. ffmpeg को अलग से इंस्टॉल करना ज़रूरी है, इसलिए यह कोडलैब आपको Cloud Run सेवा के हिस्से के तौर पर ffmpeg इंस्टॉल करने के लिए Dockerfile बनाने का तरीका बताता है.

यहां Cloud Run सेवा के काम करने का तरीका बताया गया है:

Cloud Run वीडियो के बारे में जानकारी देने वाली सेवा का डायग्राम

आपको इनके बारे में जानकारी मिलेगी

तीसरे पक्ष की बाइनरी इंस्टॉल करने के लिए, Dockerfile का इस्तेमाल करके कंटेनर इमेज बनाने का तरीका
Google Cloud की अन्य सेवाओं को कॉल करने के लिए, Cloud Run सेवा के लिए सेवा खाता बनाकर कम से कम अधिकारों के सिद्धांत का पालन करने का तरीका
Cloud Run सेवा से Video Intelligence क्लाइंट लाइब्रेरी इस्तेमाल करने का तरीका
Vertex AI की मदद से, हर सीन की विज़ुअल जानकारी पाने के लिए, Google API को कॉल करने का तरीका

2. सेटअप और ज़रूरी शर्तें

ज़रूरी शर्तें

आपने Cloud Console में लॉग इन किया है.
आपने पहले Cloud Run सेवा को डिप्लॉय किया है. उदाहरण के लिए, शुरू करने के लिए सोर्स कोड क्विकस्टार्ट की मदद से वेब सेवा डिप्लॉय करें का पालन करें.

Cloud Shell चालू करें

Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

इस वर्चुअल मशीन में डेवलपमेंट के सभी ज़रूरी टूल मौजूद हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह Google Cloud में काम करती है. यह नेटवर्क की परफ़ॉर्मेंस और ऑथेंटिकेशन को बेहतर बनाने में मदद करती है. अगर सभी नहीं, तो इस कोडलैब में आपका बहुत सारा काम ब्राउज़र से किया जा सकता है.

Cloud Shell से कनेक्ट करने के बाद, आपको दिखेगा कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट आपके प्रोजेक्ट आईडी पर सेट है.

यह पुष्टि करने के लिए Cloud Shell में नीचे दिया गया कमांड चलाएं कि आपकी पुष्टि हो गई है:

gcloud auth list

कमांड आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Cloud Shell में यह कमांड चलाएं, ताकि यह पुष्टि की जा सके कि gcloud के लिए कमांड को आपके प्रोजेक्ट के बारे में जानकारी है:

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो आप इसे इस निर्देश की मदद से सेट कर सकते हैं:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

3. एपीआई चालू करें और एनवायरमेंट वैरिएबल सेट करें

इस कोडलैब का इस्तेमाल शुरू करने से पहले, आपको कई एपीआई चालू करने होंगे. इस कोडलैब के लिए, नीचे दिए गए एपीआई का इस्तेमाल करना ज़रूरी है. नीचे दिए गए निर्देश की मदद से, उन एपीआई को चालू किया जा सकता है:

gcloud services enable run.googleapis.com \
    storage.googleapis.com \
    cloudbuild.googleapis.com \
    videointelligence.googleapis.com \
    aiplatform.googleapis.com

इसके बाद, आपके पास ऐसे एनवायरमेंट वैरिएबल सेट करने का विकल्प होता है जिनका इस्तेमाल पूरे कोडलैब के दौरान किया जाएगा.

REGION=<YOUR-REGION>
PROJECT_ID=<YOUR-PROJECT-ID>

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')
SERVICE_NAME=video-describer
export BUCKET_ID=$PROJECT_ID-video-describer

4. Cloud Storage बकेट बनाना

Cloud Storage बकेट बनाएं, जहां Cloud Run सेवा के ज़रिए प्रोसेस करने के लिए, यहां दिए गए निर्देश का इस्तेमाल करके वीडियो अपलोड किए जा सकें:

gsutil mb -l us-central1 gs://$BUCKET_ID/

[ज़रूरी नहीं] इस सैंपल वीडियो को डिवाइस पर डाउनलोड करके, इसका इस्तेमाल किया जा सकता है.

gsutil cp gs://cloud-samples-data/video/visionapi.mp4 testvideo.mp4

अब अपनी वीडियो फ़ाइल को स्टोरेज बकेट में अपलोड करें.

FILENAME=<YOUR-VIDEO-FILENAME>
gsutil cp $FILENAME gs://$BUCKET_ID

5. Node.js ऐप्लिकेशन बनाना

सबसे पहले, सोर्स कोड के लिए एक डायरेक्ट्री बनाएं और उस डायरेक्ट्री में cd डालें.

mkdir video-describer && cd $_

इसके बाद, इस कॉन्टेंट के साथ एक Package.json फ़ाइल बनाएं:

{
  "name": "video-describer",
  "version": "1.0.0",
  "private": true,
  "description": "describes the image in every scene for a given video",
  "main": "index.js",
  "author": "Google LLC",
  "license": "Apache-2.0",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "@google-cloud/storage": "^7.7.0",
    "@google-cloud/video-intelligence": "^5.0.1",
    "axios": "^1.6.2",
    "express": "^4.18.2",
    "fluent-ffmpeg": "^2.1.2",
    "google-auth-library": "^9.4.1"
  }
}

इस ऐप्लिकेशन में कई सोर्स फ़ाइलें हैं, ताकि उन्हें आसानी से पढ़ा जा सके. सबसे पहले, नीचे दिए गए कॉन्टेंट के साथ index.js सोर्स फ़ाइल बनाएं. इस फ़ाइल में सेवा का एंट्री पॉइंट और ऐप्लिकेशन का मुख्य लॉजिक शामिल है.

const { captureImages } = require('./imageCapture.js');
const { detectSceneChanges } = require('./sceneDetector.js');
const transcribeScene = require('./imageDescriber.js');
const { Storage } = require('@google-cloud/storage');
const fs = require('fs').promises;
const path = require('path');
const express = require('express');
const app = express();

const bucketName = process.env.BUCKET_ID;

const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => {
  console.log(`video describer service ready: listening on port ${port}`);
});

// entry point for the service
app.get('/', async (req, res) => {

  try {

    // download the requested video from Cloud Storage
    let videoFilename =  req.query.filename; 
    console.log("processing file: " + videoFilename);

    // download the file to locally to the Cloud Run instance
    let localFilename = await downloadVideoFile(videoFilename);

    // detect all the scenes in the video & save timestamps to an array
    let timestamps = await detectSceneChanges(localFilename);
    console.log("Detected scene changes at the following timestamps: ", timestamps);

    // create an image of each scene change
    // and save to a local directory called "output"
    await captureImages(localFilename, timestamps);

    // get an access token for the Service Account to call the Google APIs 
    let accessToken = await transcribeScene.getAccessToken();
    console.log("got an access token");

    let imageBaseName = path.parse(localFilename).name;

    // the data structure for storing the scene description and timestamp
    // e.g. an array of json objects {timestamp: 1, description: "..."}, etc.    
    let scenes = []

    // for each timestamp, send the image to Vertex AI
    console.log("getting Vertex AI description all the timestamps");
    scenes = await Promise.all(
      timestamps.map(async (timestamp) => {

        let filepath = path.join("./output", imageBaseName + "-" + timestamp + ".png");

        // get the base64 encoded image
        const encodedFile = await fs.readFile(filepath, 'base64');

        // send each screenshot to Vertex AI for description
        let description = await transcribeScene.transcribeScene(accessToken, encodedFile)

        return { timestamp: timestamp, description: description };
      }));

    console.log("finished collecting all the scenes");
    //console.log(scenes);

    return res.json(scenes);

  } catch (error) {

    //return an error
    console.log("received error: ", error);
    return res.status(500).json("an internal error occurred");
  }

});

async function downloadVideoFile(videoFilename) {
  // Creates a client
  const storage = new Storage();

  // keep same name locally
  let localFilename = videoFilename;

  const options = {
    destination: localFilename
  };

  // Download the file
  await storage.bucket(bucketName).file(videoFilename).download(options);

  console.log(
    `gs://${bucketName}/${videoFilename} downloaded locally to ${localFilename}.`
  );

  return localFilename;
}

इसके बाद, इस कॉन्टेंट के साथ एक screenDetector.js फ़ाइल बनाएं. यह फ़ाइल, Video Intelligence API का इस्तेमाल करती है, ताकि यह पता लगाया जा सके कि वीडियो के सीन कब बदलते हैं.

const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);
const ffmpeg = require('fluent-ffmpeg');

const Video = require('@google-cloud/video-intelligence');
const client = new Video.VideoIntelligenceServiceClient();

module.exports = {
    detectSceneChanges: async function (downloadedFile) {

        // Reads a local video file and converts it to base64       
        const file = await readFile(downloadedFile);
        const inputContent = file.toString('base64');

        // setup request for shot change detection
        const videoContext = {
            speechTranscriptionConfig: {
                languageCode: 'en-US',
                enableAutomaticPunctuation: true,
            },
        };

        const request = {
            inputContent: inputContent,
            features: ['SHOT_CHANGE_DETECTION'],
        };

        // Detects camera shot changes
        const [operation] = await client.annotateVideo(request);
        console.log('Shot (scene) detection in progress...');
        const [operationResult] = await operation.promise();

        // Gets shot changes
        const shotChanges = operationResult.annotationResults[0].shotAnnotations;

        console.log("Shot (scene) changes detected: " + shotChanges.length);

        // data structure to be returned 
        let sceneChanges = [];

        // for the initial scene
        sceneChanges.push(1);

        // if only one scene, keep at 1 second
        if (shotChanges.length === 1) {
            return sceneChanges;
        }

        // get length of video
        const videoLength = await getVideoLength(downloadedFile);

        shotChanges.forEach((shot, shotIndex) => {
            if (shot.endTimeOffset === undefined) {
                shot.endTimeOffset = {};
            }
            if (shot.endTimeOffset.seconds === undefined) {
                shot.endTimeOffset.seconds = 0;
            }
            if (shot.endTimeOffset.nanos === undefined) {
                shot.endTimeOffset.nanos = 0;
            }

            // convert to a number
            let currentTimestampSecond = Number(shot.endTimeOffset.seconds);                  

            let sceneChangeTime = 0;
            // double-check no scenes were detected within the last second
            if (currentTimestampSecond + 1 > videoLength) {
                sceneChangeTime = currentTimestampSecond;                
            } else {
                // otherwise, for simplicity, just round up to the next second 
                sceneChangeTime = currentTimestampSecond + 1;
            }

            sceneChanges.push(sceneChangeTime);
        });

        return sceneChanges;
    }
}

async function getVideoLength(localFile) {
    let getLength = util.promisify(ffmpeg.ffprobe);
    let length = await getLength(localFile);

    console.log("video length: ", length.format.duration);
    return length.format.duration;
}

अब नीचे दिए गए कॉन्टेंट के साथ, Image Capture.js नाम की एक फ़ाइल बनाएं. यह फ़ाइल किसी नोड ऐप्लिकेशन में ffmpeg कमांड चलाने के लिए fluent-ffmpeg नोड पैकेज का इस्तेमाल करती है.

const ffmpeg = require('fluent-ffmpeg');
const path = require('path');
const util = require('util');


module.exports = {
    captureImages: async function (localFile, scenes) {


        let imageBaseName = path.parse(localFile).name;


        try {
            for (scene of scenes) {
                console.log("creating screenshot for scene: ", + scene);
                await createScreenshot(localFile, imageBaseName, scene);
            }


        } catch (error) {
            console.log("error gathering screenshots: ", error);
        }


        console.log("finished gathering the screenshots");
    }
}


async function createScreenshot(localFile, imageBaseName, scene) {
    return new Promise((resolve, reject) => {
        ffmpeg(localFile)
            .screenshots({
                timestamps: [scene],
                filename: `${imageBaseName}-${scene}.png`,
                folder: 'output',
                size: '320x240'
            }).on("error", () => {
                console.log("Failed to create scene for timestamp: " + scene);
                return reject('Failed to create scene for timestamp: ' + scene);
            })
            .on("end", () => {
                return resolve();
            });
    })
}

आखिर में, इस कॉन्टेंट के साथ `imageDescriber.js` नाम की एक फ़ाइल बनाएं. यह फ़ाइल, हर सीन इमेज की विज़ुअल जानकारी पाने के लिए, Vertex AI का इस्तेमाल करती है.

const axios = require("axios");
const { GoogleAuth } = require('google-auth-library');

const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform'
});

module.exports = {
    getAccessToken: async function () {

        return await auth.getAccessToken();
    }, 

    transcribeScene: async function(token, encodedFile) {

        let projectId = await auth.getProjectId();
    
        let config = {
            headers: {
                'Authorization': 'Bearer ' + token,
                'Content-Type': 'application/json; charset=utf-8'
            }
        }

        const json = {
            "instances": [
                {
                    "image": {
                        "bytesBase64Encoded": encodedFile
                    }
                }
            ],
            "parameters": {
                "sampleCount": 1,
                "language": "en"
            }
        }

        let response = await axios.post('https://us-central1-aiplatform.googleapis.com/v1/projects/' + projectId + '/locations/us-central1/publishers/google/models/imagetext:predict', json, config);

        return response.data.predictions[0];
    }
}

Dockerfile और .dockerignore फ़ाइल बनाएं

यह सेवा ffmpeg का इस्तेमाल करती है. इसलिए, आपको एक ऐसा Dockerfile बनाना होगा जो ffmpeg को इंस्टॉल करता हो.

Dockerfile नाम की ऐसी फ़ाइल बनाएं जिसमें यह कॉन्टेंट शामिल हो:

# Copyright 2020 Google, LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Use the official lightweight Node.js image.
# https://hub.docker.com/_/node
FROM node:20.10.0-slim

# Create and change to the app directory.
WORKDIR /usr/src/app

RUN apt-get update && apt-get install -y ffmpeg

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure both package.json AND package-lock.json are copied.
# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./

# Install dependencies.
# If you add a package-lock.json speed your build by switching to 'npm ci'.
# RUN npm ci --only=production
RUN npm install --production

# Copy local code to the container image.
COPY . .

# Run the web service on container startup.
CMD [ "npm", "start" ]

साथ ही, कुछ फ़ाइलों को कंटेनर में शामिल करने के लिए, .dockerignore नाम की फ़ाइल बनाएं.

Dockerfile
.dockerignore
node_modules
npm-debug.log

6. सेवा खाता बनाना

आपको Cloud Run सेवा के लिए एक सेवा खाता बनाना होगा, ताकि Cloud Storage, Vertex AI, और Video Intelligence API को ऐक्सेस करने के लिए उसका इस्तेमाल किया जा सके.

SERVICE_ACCOUNT="cloud-run-video-description"
SERVICE_ACCOUNT_ADDRESS=$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com

gcloud iam service-accounts create $SERVICE_ACCOUNT \
  --display-name="Cloud Run Video Scene Image Describer service account"
 
# to view & download storage bucket objects
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role=roles/storage.objectViewer

# to call the Vertex AI imagetext model
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \
  --role=roles/aiplatform.user

7. क्लाउड रन सेवा को डिप्लॉय करें

अब सोर्स के हिसाब से डिप्लॉयमेंट का इस्तेमाल किया जा सकता है, ताकि Cloud Run सेवा को अपने-आप कंटेनर बनाया जा सके.

ध्यान दें: Cloud Run सेवा के लिए, प्रोसेस होने का डिफ़ॉल्ट समय 60 सेकंड होता है. यह कोडलैब पांच मिनट के टाइम आउट का इस्तेमाल करता है, क्योंकि सुझाया गया टेस्ट वीडियो दो मिनट का होता है. अगर किसी लंबी अवधि का वीडियो चलाया जा रहा है, तो आपको समय में बदलाव करना पड़ सकता है.

gcloud run deploy $SERVICE_NAME \
  --region=$REGION \
  --set-env-vars BUCKET_ID=$BUCKET_ID \
  --no-allow-unauthenticated \
  --service-account $SERVICE_ACCOUNT_ADDRESS \
  --timeout=5m \
  --source=.

लागू होने के बाद, सेवा यूआरएल को किसी एनवायरमेंट वैरिएबल में सेव करें.

SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --platform managed --region $REGION --format 'value(status.url)')

8. Cloud Run सेवा को कॉल करें

अब Cloud Storage में अपलोड किए गए वीडियो का नाम देकर, सेवा देने वाली कंपनी को कॉल किया जा सकता है.

curl -X GET -H "Authorization: Bearer $(gcloud auth print-identity-token)" ${SERVICE_URL}?filename=${FILENAME}

आपके नतीजे, उदाहरण के तौर पर नीचे दिए गए आउटपुट जैसे दिखने चाहिए:

[{"timestamp":1,"description":"an aerial view of a city with a bridge in the background"},{"timestamp":7,"description":"a man in a blue shirt sits in front of shelves of donuts"},{"timestamp":11,"description":"a black and white photo of people working in a bakery"},{"timestamp":12,"description":"a black and white photo of a man and woman working in a bakery"}]

9. बधाई हो!

कोडलैब पूरा करने के लिए बधाई!

हमारा सुझाव है कि आप Video Intelligence API, Cloud Run, और Vertex AI विज़ुअल कैप्शनिंग से जुड़े दस्तावेज़ पढ़ें.

इसमें हमने इन विषयों के बारे में बताया

तीसरे पक्ष की बाइनरी इंस्टॉल करने के लिए, Dockerfile का इस्तेमाल करके कंटेनर इमेज बनाने का तरीका
Google Cloud की अन्य सेवाओं को कॉल करने के लिए, Cloud Run सेवा के लिए सेवा खाता बनाकर कम से कम अधिकारों के सिद्धांत का पालन करने का तरीका
Cloud Run सेवा से Video Intelligence क्लाइंट लाइब्रेरी इस्तेमाल करने का तरीका
Vertex AI की मदद से, हर सीन की विज़ुअल जानकारी पाने के लिए, Google API को कॉल करने का तरीका

10. व्यवस्थित करें

अनजाने में लगने वाले शुल्क से बचने के लिए, (उदाहरण के लिए, अगर Cloud Run सेवा का अनुरोध अनजाने में फ़्री टियर में हर महीने Cloud Run सुविधा के तहत असाइन किए जाने की संख्या से ज़्यादा हो, तो आप Cloud Run सेवा को मिटा सकते हैं या दूसरे चरण में बनाए गए प्रोजेक्ट को मिटा सकते हैं.

क्लाउड रन सेवा को मिटाने के लिए, https://console.cloud.google.com/run/ पर Cloud Run Cloud Console पर जाएं और video-describer फ़ंक्शन को मिटाएं. अगर आपने किसी दूसरे नाम का इस्तेमाल किया है, तो $SERVICE_NAME को मिटाएं.

अगर आपको पूरा प्रोजेक्ट मिटाना है, तो https://console.cloud.google.com/cloud-resource-manager पर जाएं और दूसरे चरण में बनाया गया प्रोजेक्ट चुनें. इसके बाद, 'मिटाएं' चुनें. अगर प्रोजेक्ट मिटाया जाता है, तो आपको Cloud SDK में प्रोजेक्ट बदलने होंगे. gcloud projects list चलाकर, सभी उपलब्ध प्रोजेक्ट की सूची देखी जा सकती है.