오디오 입력 파일로 인텐트 감지

이 가이드에서는 API를 사용하여 오디오 입력 요청을 인텐트 감지 요청으로 보내는 방법을 설명합니다. Dialogflow는 인텐트 일치를 시도하기 전에 오디오를 처리하여 텍스트로 변환합니다. 이러한 변환을 음성 입력, 음성 인식, 음성 텍스트 변환 또는 STT라고 합니다.

시작하기 전에

이 기능은 최종 사용자 상호작용에 API를 사용할 경우에만 적용됩니다. 통합을 사용할 경우 이 가이드를 건너뛰어도 됩니다.

이 가이드를 읽기 전에 다음을 수행해야 합니다.

  1. Dialogflow 기본사항 읽기
  2. 설정 단계 수행

에이전트 만들기

이 가이드의 단계에서는 에이전트를 가정하므로 새 에이전트로 시작하는 것이 좋습니다. 새 에이전트를 만들기 전에 프로젝트의 기존 에이전트를 삭제해야 합니다. 기존 에이전트를 삭제하려면 다음 안내를 따르세요.

  1. Dialogflow 콘솔로 이동합니다.
  2. 로그인 메시지가 표시되면 Dialogflow 콘솔에 로그인합니다. 자세한 내용은 Dialogflow 콘솔 개요를 참조하세요.
  3. 삭제할 에이전트를 선택합니다.
  4. 에이전트 이름 옆에 있는 설정 settings 버튼을 클릭합니다.
  5. 아래로 스크롤하여 일반 설정 탭으로 이동합니다.
  6. 이 에이전트 삭제를 클릭합니다.
  7. 텍스트 필드에 DELETE를 입력합니다.
  8. 삭제를 클릭합니다.

에이전트를 만들려면 다음 안내를 따르세요.

  1. Dialogflow 콘솔로 이동합니다.
  2. 로그인 메시지가 표시되면 Dialogflow 콘솔에 로그인합니다. 자세한 내용은 Dialogflow 콘솔 개요를 참조하세요.
  3. 왼쪽 사이드바 메뉴에서 에이전트 만들기를 클릭합니다. 이미 다른 에이전트가 있는 경우 에이전트 이름을 클릭하고 아래로 스크롤하여 새 에이전트 만들기를 클릭합니다.
  4. 에이전트 이름, 기본 언어, 기본 시간대를 입력합니다.
  5. 프로젝트를 이미 만든 경우 이 프로젝트를 입력합니다. Dialogflow 콘솔에서 프로젝트를 만들 수 있도록 허용하려면 새 Google 프로젝트 만들기를 선택합니다.
  6. 만들기 버튼을 클릭합니다.

에이전트로 예제 파일 가져오기

가져오기를 수행하면 에이전트에 인텐트와 항목이 추가됩니다. 기존 인텐트 또는 항목의 이름이 가져온 파일에 있는 인텐트 또는 항목의 이름과 같으면 대체됩니다.

파일을 가져오려면 다음 단계를 따르세요.

  1. RoomReservation.zip 파일을 다운로드합니다.
  2. Dialogflow 콘솔로 이동합니다.
  3. 에이전트를 선택합니다.
  4. 에이전트 이름 옆에 있는 설정 settings 버튼을 클릭합니다.
  5. 내보내기 및 가져오기 탭을 선택합니다.
  6. ZIP 파일에서 가져오기를 선택하고 다운로드한 ZIP 파일을 가져옵니다.

인텐트 감지

REST 및 명령줄

인텐트를 감지하려면 Sessions 유형에서 detectIntent 메서드를 호출합니다.

'book a room'이라고 말하는 샘플 입력 오디오 파일 book_a_room.wav를 다운로드합니다. 이 예시에서 오디오 파일은 base64로 인코딩되어야 하므로 아래의 JSON 요청으로 오디오 파일을 제공할 수 있습니다. 다음은 Linux 예시입니다.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/java-docs-samples/master/dialogflow/cloud-client/resources/book_a_room.wav
    base64 -w 0 book_a_room.wav > book_a_room.b64
    

다른 플랫폼에 대한 예시는 Cloud Speech-to-Text API 문서의 오디오 콘텐츠를 Base64로 인코딩을 참조하세요.

아래의 요청 데이터를 사용하기 전에 다음을 바꿉니다.

  • project-id: GCP 프로젝트 ID
  • audio: base64로 인코딩된 오디오 콘텐츠

HTTP 메소드 및 URL:

POST https://dialogflow.googleapis.com/v2/projects/project-id/agent/sessions/123456789:detectIntent

JSON 요청 본문:

    {
      "queryInput": {
        "audioConfig": {
          "languageCode": "en-US"
        }
      },
      "inputAudio": "audio"
    }
    

요청을 보내려면 다음 옵션 중 하나를 펼칩니다.

다음과 비슷한 JSON 응답이 표시됩니다.

    {
      "responseId": "3c1e5a89-75b9-4c3f-b63d-4b1351dd5e32",
      "queryResult": {
        "queryText": "book a room",
        "action": "room.reservation",
        "parameters": {
          "time": "",
          "date": "",
          "guests": "",
          "duration": "",
          "location": ""
        },
        "fulfillmentText": "I can help with that. Where would you like to reserve a room?",
        "fulfillmentMessages": [
          {
            "text": {
              "text": [
                "I can help with that. Where would you like to reserve a room?"
              ]
            },
            "platform": "FACEBOOK"
          },
          {
            "text": {
              "text": [
                "I can help with that. Where would you like to reserve a room?"
              ]
            }
          }
        ],
        "outputContexts": [
          {
            "name": "projects/project-id/agent/sessions/123456789/contexts/e8f6a63e-73da-4a1a-8bfc-857183f71228_id_dialog_context",
            "lifespanCount": 2,
            "parameters": {
              "date": "",
              "guests": "",
              "duration": "",
              "location.original": "",
              "guests.original": "",
              "location": "",
              "date.original": "",
              "time.original": "",
              "time": "",
              "duration.original": ""
            }
          },
          {
            "name": "projects/project-id/agent/sessions/123456789/contexts/room_reservation_dialog_params_location",
            "lifespanCount": 1,
            "parameters": {
              "date.original": "",
              "time.original": "",
              "time": "",
              "duration.original": "",
              "date": "",
              "guests": "",
              "duration": "",
              "location.original": "",
              "guests.original": "",
              "location": ""
            }
          },
          {
            "name": "projects/project-id/agent/sessions/123456789/contexts/room_reservation_dialog_context",
            "lifespanCount": 2,
            "parameters": {
              "time.original": "",
              "time": "",
              "duration.original": "",
              "date": "",
              "guests": "",
              "duration": "",
              "location.original": "",
              "guests.original": "",
              "location": "",
              "date.original": ""
            }
          }
        ],
        "intent": {
          "name": "projects/project-id/agent/intents/e8f6a63e-73da-4a1a-8bfc-857183f71228",
          "displayName": "room.reservation"
        },
        "intentDetectionConfidence": 1,
        "diagnosticInfo": {},
        "languageCode": "en-us"
      }
    }
    

queryResult.action 필드 값은 'room.reservation'이고, queryResult.fulfillmentMessages[0|1].text.text[0] 필드 값은 사용자에게 추가 정보를 요청합니다.

Go

func DetectIntentAudio(projectID, sessionID, audioFile, languageCode string) (string, error) {
    	ctx := context.Background()

    	sessionClient, err := dialogflow.NewSessionsClient(ctx)
    	if err != nil {
    		return "", err
    	}
    	defer sessionClient.Close()

    	if projectID == "" || sessionID == "" {
    		return "", errors.New(fmt.Sprintf("Received empty project (%s) or session (%s)", projectID, sessionID))
    	}

    	sessionPath := fmt.Sprintf("projects/%s/agent/sessions/%s", projectID, sessionID)

    	// In this example, we hard code the encoding and sample rate for simplicity.
    	audioConfig := dialogflowpb.InputAudioConfig{AudioEncoding: dialogflowpb.AudioEncoding_AUDIO_ENCODING_LINEAR_16, SampleRateHertz: 16000, LanguageCode: languageCode}

    	queryAudioInput := dialogflowpb.QueryInput_AudioConfig{AudioConfig: &audioConfig}

    	audioBytes, err := ioutil.ReadFile(audioFile)
    	if err != nil {
    		return "", err
    	}

    	queryInput := dialogflowpb.QueryInput{Input: &queryAudioInput}
    	request := dialogflowpb.DetectIntentRequest{Session: sessionPath, QueryInput: &queryInput, InputAudio: audioBytes}

    	response, err := sessionClient.DetectIntent(ctx, &request)
    	if err != nil {
    		return "", err
    	}

    	queryResult := response.GetQueryResult()
    	fulfillmentText := queryResult.GetFulfillmentText()
    	return fulfillmentText, nil
    }
    

자바


    /**
     * Returns the result of detect intent with an audio file as input.
     *
     * Using the same `session_id` between requests allows continuation of the conversation.
     *
     * @param projectId     Project/Agent Id.
     * @param audioFilePath Path to the audio file.
     * @param sessionId     Identifier of the DetectIntent session.
     * @param languageCode  Language code of the query.
     * @return QueryResult for the request.
     */
    public static QueryResult detectIntentAudio(
        String projectId,
        String audioFilePath,
        String sessionId,
        String languageCode)
        throws Exception {
      // Instantiates a client
      try (SessionsClient sessionsClient = SessionsClient.create()) {
        // Set the session name using the sessionId (UUID) and projectID (my-project-id)
        SessionName session = SessionName.of(projectId, sessionId);
        System.out.println("Session Path: " + session.toString());

        // Note: hard coding audioEncoding and sampleRateHertz for simplicity.
        // Audio encoding of the audio content sent in the query request.
        AudioEncoding audioEncoding = AudioEncoding.AUDIO_ENCODING_LINEAR_16;
        int sampleRateHertz = 16000;

        // Instructs the speech recognizer how to process the audio content.
        InputAudioConfig inputAudioConfig = InputAudioConfig.newBuilder()
            .setAudioEncoding(audioEncoding) // audioEncoding = AudioEncoding.AUDIO_ENCODING_LINEAR_16
            .setLanguageCode(languageCode) // languageCode = "en-US"
            .setSampleRateHertz(sampleRateHertz) // sampleRateHertz = 16000
            .build();

        // Build the query with the InputAudioConfig
        QueryInput queryInput = QueryInput.newBuilder().setAudioConfig(inputAudioConfig).build();

        // Read the bytes from the audio file
        byte[] inputAudio = Files.readAllBytes(Paths.get(audioFilePath));

        // Build the DetectIntentRequest
        DetectIntentRequest request = DetectIntentRequest.newBuilder()
            .setSession(session.toString())
            .setQueryInput(queryInput)
            .setInputAudio(ByteString.copyFrom(inputAudio))
            .build();

        // Performs the detect intent request
        DetectIntentResponse response = sessionsClient.detectIntent(request);

        // Display the query result
        QueryResult queryResult = response.getQueryResult();
        System.out.println("====================");
        System.out.format("Query Text: '%s'\n", queryResult.getQueryText());
        System.out.format("Detected Intent: %s (confidence: %f)\n",
            queryResult.getIntent().getDisplayName(), queryResult.getIntentDetectionConfidence());
        System.out.format("Fulfillment Text: '%s'\n", queryResult.getFulfillmentText());

        return queryResult;
      }
    }

Node.js

const fs = require('fs');
    const util = require('util');
    const {struct} = require('pb-util');
    // Imports the Dialogflow library
    const dialogflow = require('dialogflow');

    // Instantiates a session client
    const sessionClient = new dialogflow.SessionsClient();

    // The path to identify the agent that owns the created intent.
    const sessionPath = sessionClient.sessionPath(projectId, sessionId);

    // Read the content of the audio file and send it as part of the request.
    const readFile = util.promisify(fs.readFile);
    const inputAudio = await readFile(filename);
    const request = {
      session: sessionPath,
      queryInput: {
        audioConfig: {
          audioEncoding: encoding,
          sampleRateHertz: sampleRateHertz,
          languageCode: languageCode,
        },
      },
      inputAudio: inputAudio,
    };

    // Recognizes the speech in the audio and detects its intent.
    const [response] = await sessionClient.detectIntent(request);

    console.log('Detected intent:');
    const result = response.queryResult;
    // Instantiates a context client
    const contextClient = new dialogflow.ContextsClient();

    console.log(`  Query: ${result.queryText}`);
    console.log(`  Response: ${result.fulfillmentText}`);
    if (result.intent) {
      console.log(`  Intent: ${result.intent.displayName}`);
    } else {
      console.log(`  No intent matched.`);
    }
    const parameters = JSON.stringify(struct.decode(result.parameters));
    console.log(`  Parameters: ${parameters}`);
    if (result.outputContexts && result.outputContexts.length) {
      console.log(`  Output contexts:`);
      result.outputContexts.forEach(context => {
        const contextId = contextClient.matchContextFromContextName(context.name);
        const contextParameters = JSON.stringify(
          struct.decode(context.parameters)
        );
        console.log(`    ${contextId}`);
        console.log(`      lifespan: ${context.lifespanCount}`);
        console.log(`      parameters: ${contextParameters}`);
      });
    }

PHP

namespace Google\Cloud\Samples\Dialogflow;

    use Google\Cloud\Dialogflow\V2\SessionsClient;
    use Google\Cloud\Dialogflow\V2\AudioEncoding;
    use Google\Cloud\Dialogflow\V2\InputAudioConfig;
    use Google\Cloud\Dialogflow\V2\QueryInput;

    /**
    * Returns the result of detect intent with an audio file as input.
    * Using the same `session_id` between requests allows continuation
    * of the conversation.
    */
    function detect_intent_audio($projectId, $path, $sessionId, $languageCode = 'en-US')
    {
        // new session
        $sessionsClient = new SessionsClient();
        $session = $sessionsClient->sessionName($projectId, $sessionId ?: uniqid());
        printf('Session path: %s' . PHP_EOL, $session);

        // load audio file
        $inputAudio = file_get_contents($path);

        // hard coding audio_encoding and sample_rate_hertz for simplicity
        $audioConfig = new InputAudioConfig();
        $audioConfig->setAudioEncoding(AudioEncoding::AUDIO_ENCODING_LINEAR_16);
        $audioConfig->setLanguageCode($languageCode);
        $audioConfig->setSampleRateHertz(16000);

        // create query input
        $queryInput = new QueryInput();
        $queryInput->setAudioConfig($audioConfig);

        // get response and relevant info
        $response = $sessionsClient->detectIntent($session, $queryInput, ['inputAudio' => $inputAudio]);
        $queryResult = $response->getQueryResult();
        $queryText = $queryResult->getQueryText();
        $intent = $queryResult->getIntent();
        $displayName = $intent->getDisplayName();
        $confidence = $queryResult->getIntentDetectionConfidence();
        $fulfilmentText = $queryResult->getFulfillmentText();

        // output relevant info
        print(str_repeat("=", 20) . PHP_EOL);
        printf('Query text: %s' . PHP_EOL, $queryText);
        printf('Detected intent: %s (confidence: %f)' . PHP_EOL, $displayName,
            $confidence);
        print(PHP_EOL);
        printf('Fulfilment text: %s' . PHP_EOL, $fulfilmentText);

        $sessionsClient->close();
    }

Python

def detect_intent_audio(project_id, session_id, audio_file_path,
                            language_code):
        """Returns the result of detect intent with an audio file as input.

        Using the same `session_id` between requests allows continuation
        of the conversation."""
        import dialogflow_v2 as dialogflow

        session_client = dialogflow.SessionsClient()

        # Note: hard coding audio_encoding and sample_rate_hertz for simplicity.
        audio_encoding = dialogflow.enums.AudioEncoding.AUDIO_ENCODING_LINEAR_16
        sample_rate_hertz = 16000

        session = session_client.session_path(project_id, session_id)
        print('Session path: {}\n'.format(session))

        with open(audio_file_path, 'rb') as audio_file:
            input_audio = audio_file.read()

        audio_config = dialogflow.types.InputAudioConfig(
            audio_encoding=audio_encoding, language_code=language_code,
            sample_rate_hertz=sample_rate_hertz)
        query_input = dialogflow.types.QueryInput(audio_config=audio_config)

        response = session_client.detect_intent(
            session=session, query_input=query_input,
            input_audio=input_audio)

        print('=' * 20)
        print('Query text: {}'.format(response.query_result.query_text))
        print('Detected intent: {} (confidence: {})\n'.format(
            response.query_result.intent.display_name,
            response.query_result.intent_detection_confidence))
        print('Fulfillment text: {}\n'.format(
            response.query_result.fulfillment_text))

Ruby

# project_id = "Your Google Cloud project ID"
    # session_id = "mysession"
    # audio_file_path = "resources/book_a_room.wav"
    # language_code = "en-US"

    require "google/cloud/dialogflow"

    session_client = Google::Cloud::Dialogflow::Sessions.new
    session = session_client.class.session_path project_id, session_id
    puts "Session path: #{session}"

    begin
      audio_file = File.open audio_file_path, "rb"
      input_audio = audio_file.read
    ensure
      audio_file.close
    end

    audio_config = {
      audio_encoding:    :AUDIO_ENCODING_LINEAR_16,
      sample_rate_hertz: 16_000,
      language_code:     language_code
    }

    query_input = { audio_config: audio_config }

    response = session_client.detect_intent session, query_input, input_audio: input_audio
    query_result = response.query_result

    puts "Query text:        #{query_result.query_text}"
    puts "Intent detected:   #{query_result.intent.display_name}"
    puts "Intent confidence: #{query_result.intent_detection_confidence}"
    puts "Fulfillment text:  #{query_result.fulfillment_text}"