Recherche avancée

Sur d’autres sites (7813)

• Computer crashing when using python tools in same script

  5 février 2023, par SL1997

  I am attempting to use the speech recognition toolkit VOSK and the speech diarization package Resemblyzer to transcibe audio and then identify the speakers in the audio.

  


  Tools :

  


  https://github.com/alphacep/vosk-api
  
https://github.com/resemble-ai/Resemblyzer

  


  I can do both things individually but run into issues when trying to do them when running the one python script.

  


  I used the following guide when setting up the diarization system :

  


  https://medium.com/saarthi-ai/who-spoke-when-build-your-own-speaker-diarization-module-from-scratch-e7d725ee279

  


  Computer specs are as follows :

  


  Intel(R) Core(TM) i3-7100 CPU @ 3.90GHz, 3912 Mhz, 2 Core(s), 4 Logical Processor(s)
  
32GB RAM

  


  The following is my code, I am not to sure if using threading is appropriate or if I even implemented it correctly, how can I best optimize this code as to achieve the results I am looking for and not crash.

  


  from vosk import Model, KaldiRecognizer
from pydub import AudioSegment
import json
import sys
import os
import subprocess
import datetime
from resemblyzer import preprocess_wav, VoiceEncoder
from pathlib import Path
from resemblyzer.hparams import sampling_rate
from spectralcluster import SpectralClusterer
import threading
import queue
import gc



def recognition(queue, audio, FRAME_RATE):

    model = Model("Vosk_Models/vosk-model-small-en-us-0.15")

    rec = KaldiRecognizer(model, FRAME_RATE)
    rec.SetWords(True)

    rec.AcceptWaveform(audio.raw_data)
    result = rec.Result()

    transcript = json.loads(result)#["text"]

    #return transcript
    queue.put(transcript)



def diarization(queue, audio):

    wav = preprocess_wav(audio)
    encoder = VoiceEncoder("cpu")
    _, cont_embeds, wav_splits = encoder.embed_utterance(wav, return_partials=True, rate=16)
    print(cont_embeds.shape)

    clusterer = SpectralClusterer(
        min_clusters=2,
        max_clusters=100,
        p_percentile=0.90,
        gaussian_blur_sigma=1)

    labels = clusterer.predict(cont_embeds)

    def create_labelling(labels, wav_splits):

        times = [((s.start + s.stop) / 2) / sampling_rate for s in wav_splits]
        labelling = []
        start_time = 0

        for i, time in enumerate(times):
            if i > 0 and labels[i] != labels[i - 1]:
                temp = [str(labels[i - 1]), start_time, time]
                labelling.append(tuple(temp))
                start_time = time
            if i == len(times) - 1:
                temp = [str(labels[i]), start_time, time]
                labelling.append(tuple(temp))

        return labelling

    #return
    labelling = create_labelling(labels, wav_splits)
    queue.put(labelling)



def identify_speaker(queue1, queue2):

    transcript = queue1.get()
    labelling = queue2.get()

    for speaker in labelling:

        speakerID = speaker[0]
        speakerStart = speaker[1]
        speakerEnd = speaker[2]

        result = transcript['result']
        words = [r['word'] for r in result if speakerStart < r['start'] < speakerEnd]
        #return
        print("Speaker",speakerID,":",' '.join(words), "\n")





def main():

    queue1 = queue.Queue()
    queue2 = queue.Queue()

    FRAME_RATE = 16000
    CHANNELS = 1

    podcast = AudioSegment.from_mp3("Podcast_Audio/Film-Release-Clip.mp3")
    podcast = podcast.set_channels(CHANNELS)
    podcast = podcast.set_frame_rate(FRAME_RATE)

    first_thread = threading.Thread(target=recognition, args=(queue1, podcast, FRAME_RATE))
    second_thread = threading.Thread(target=diarization, args=(queue2, podcast))
    third_thread = threading.Thread(target=identify_speaker, args=(queue1, queue2))

    first_thread.start()
    first_thread.join()
    gc.collect()

    second_thread.start()
    second_thread.join()
    gc.collect()

    third_thread.start()
    third_thread.join()
    gc.collect()

    # transcript = recognition(podcast,FRAME_RATE)
    #
    # labelling = diarization(podcast)
    #
    # print(identify_speaker(transcript, labelling))


if __name__ == '__main__':
    main()


  


  When I say crash I mean everything freezes, I have to hold down the power button on the desktop and turn it back on again. No blue/blank screen, just frozen in my IDE looking at my code. Any help in resolving this issue would be greatly appreciated.

  


• How to sell Piwik services without any confusion ?

  10 octobre 2017, par InnoCraft — Plugins

  As you may know, Piwik is a Free software under the GPL license which guarantees you :

  • The freedom to run the program for any purpose.
  • The freedom to study how it works and change it.
  • The freedom to improve the program, and release your changes.
  • The freedom to redistribute it under the GPL license, and to sell it if you wish.

  In this article we will focus on the Free aspect of Piwik, which is how to rebrand Piwik, how to offer your clients a better experience, and possibly how to make a profit from it ?

  How to sell Piwik services as an agency ?

  As a web analytics software, Piwik is often installed by web agencies when it comes to designing a brand new website for a given customer.
  Most of the time agencies are using Piwik for the following reasons :

  • free of charge
  • data ownership
  • user privacy compliance
  • feature rich while easy to use
  • open source

  Most of the agencies are charging their customers for the installation process, tracking code implementation, analysing reports to get insights about users… but do you know that you could also sell the software as your own brand ? This is where the “White Label” plugin, developed by the InnoCraft company, comes into play.

  White labelling for Piwik

  Creating a “white label” plugin came into the mind of InnoCraft founders when they realized that on any modern Piwik installation, the following components were visible :

  • Piwik branded widgets within the dashboards
  • Piwik marketplace plugin teasers on the admin page
  • Piwik help and support pages
  • the “Piwik” word in general
  • Piwik Mobile app banners

  

  Example of Piwik branded widgets

  In order to remove all those mentions of Piwik and to start selling this web analytics under your own name, you can either hack Piwik on your own (it is going to take you some precious time and money) or have a look at the White Label plugin on the marketplace where InnoCraft has solved all the challenges already for you.

  The White Label plugin is straightforward. Once downloaded and installed, you will have access to a dedicated interface where you will be able to change the Piwik name by a new custom brand of your choice :

  

  Piwik White Label settings

  Once you click Save, all “Piwik” mentions will be substituted by your company name/service :

  

  Here the Piwik version is changed by the name of the company

  How to make your installation even more customized ?

  Few Piwik users know about this trick, but since 2014 the Piwik templates can be customized through Themes. You are free to design your own template, installing existing ones, or even monetize them through the marketplace :

  

  A simple example of how Piwik can be easily customized, here fonts and colours are changed

  If you want to know how you can tweak your existing template and make it match your brand and image, just follow our theme documentation. A simple theme with your colors can be built in a few minutes simply by defining different color codes. You can also browse the public themes on the Marketplace.

  Get White Label for Piwik

  Tell us your story

  If you are an agency or any business related in selling Piwik services, we recommend having a look at our FAQ for rebranding, selling, reusing, re-licensing, and including Piwik in my offering. Are you interested or already re-selling Piwik services ? We would love to hear your story and write a blog post about it.

  Write for Piwik

  Do not hesitate to contact the Piwik core team, we’re looking forward to hearing from you.

• How to compress webcam videos recorded by html5 MediaRecorder api ?

  25 mai 2017, par JasonY

  I successfully recorded my webcam using MediaRecorder api and the resulting filesizes seemed far too big for their quality.

  For example, for an 8 second video that was 480x640 I got a 1mB file size. That does not seem right.

  My code to record()

  navigator.mediaDevices.getUserMedia({video: true, audio: true})
  
      .then(function(stream){
  
          var options = {
  
              mimeType : "video/webm;codecs=vp9"
  
              //I don't set bitrate here even if I do the quality is too bad
  
          }
  
          var media_recorder = new MediaRecorder(media_stream, options);
  
          var recorded_data = [];
  
          media_recorder.ondataavailable = function(e){
  
               recorded_data.push(e.data);
  
          }
  
          media_recorder.onstop = function(e){
  
              recorded_data.push(e.data);
  
              var recorded_blob = new Blob(recorded_data, { 'type' : 'video/webm; codecs=vp9' });
  
              var recorded_video_url = window.URL.createObjectURL(recorded_blob);
  
              //here I write some code to download the blob from this url through a href
  
          }
  
      })

  The file obtained by this method is unreasonably large which makes me wonder if it was even compressed when encoded by VP9 ? A 7 second video is about 870kB !

  Inspecting the file with a mediainfo tool gives me

  General
  
  Count                                    : 323
  
  Count of stream of this kind             : 1
  
  Kind of stream                           : General
  
  Kind of stream                           : General
  
  Stream identifier                        : 0
  
  Count of video streams                   : 1
  
  Count of audio streams                   : 1
  
  Video_Format_List                        : VP9
  
  Video_Format_WithHint_List               : VP9
  
  Codecs Video                             : V_VP9
  
  Video_Language_List                      : English
  
  Audio_Format_List                        : Opus
  
  Audio_Format_WithHint_List               : Opus
  
  Audio codecs                             : Opus
  
  Audio_Language_List                      : English
  
  Complete name                            : recorded_video.webm
  
  File name                                : recorded_video
  
  File extension                           : webm
  
  Format                                   : WebM
  
  Format                                   : WebM
  
  Format/Url                               : http://www.webmproject.org/
  
  Format/Extensions usually used           : webm
  
  Commercial name                          : WebM
  
  Format version                           : Version 2
  
  Internet media type                      : video/webm
  
  Codec                                    : WebM
  
  Codec                                    : WebM
  
  Codec/Url                                : http://www.webmproject.org/
  
  Codec/Extensions usually used            : webm
  
  File size                                : 867870
  
  File size                                : 848 KiB
  
  File size                                : 848 KiB
  
  File size                                : 848 KiB
  
  File size                                : 848 KiB
  
  File size                                : 847.5 KiB
  
  File last modification date              : UTC 2017-05-19 05:48:00
  
  File last modification date (local)      : 2017-05-19 17:48:00
  
  Writing application                      : Chrome
  
  Writing application                      : Chrome
  
  Writing library                          : Chrome
  
  Writing library                          : Chrome
  
  IsTruncated                              : Yes
  
  
  
  Video
  
  Count                                    : 332
  
  Count of stream of this kind             : 1
  
  Kind of stream                           : Video
  
  Kind of stream                           : Video
  
  Stream identifier                        : 0
  
  StreamOrder                              : 1
  
  ID                                       : 2
  
  ID                                       : 2
  
  Unique ID                                : 62101435245162993
  
  Format                                   : VP9
  
  Commercial name                          : VP9
  
  Codec ID                                 : V_VP9
  
  Codec ID/Url                             : http://www.webmproject.org/
  
  Codec                                    : V_VP9
  
  Codec                                    : V_VP9
  
  Width                                    : 640
  
  Width                                    : 640 pixels
  
  Height                                   : 480
  
  Height                                   : 480 pixels
  
  Pixel aspect ratio                       : 1.000
  
  Display aspect ratio                     : 1.333
  
  Display aspect ratio                     : 4:3
  
  Frame rate mode                          : VFR
  
  Frame rate mode                          : Variable
  
  Language                                 : en
  
  Language                                 : English
  
  Language                                 : English
  
  Language                                 : en
  
  Language                                 : eng
  
  Language                                 : en
  
  Default                                  : Yes
  
  Default                                  : Yes
  
  Forced                                   : No
  
  Forced                                   : No
  
  
  
  Audio
  
  Count                                    : 272
  
  Count of stream of this kind             : 1
  
  Kind of stream                           : Audio
  
  Kind of stream                           : Audio
  
  Stream identifier                        : 0
  
  StreamOrder                              : 0
  
  ID                                       : 1
  
  ID                                       : 1
  
  Unique ID                                : 32224324715799545
  
  Format                                   : Opus
  
  Format/Url                               : http://opus-codec.org/
  
  Commercial name                          : Opus
  
  Internet media type                      : audio/opus
  
  Codec ID                                 : A_OPUS
  
  Codec ID/Url                             : http://opus-codec.org
  
  Codec                                    : Opus
  
  Codec                                    : Opus
  
  Codec/Family                             : PCM
  
  Channel(s)                               : 1
  
  Channel(s)                               : 1 channel
  
  Channel positions                        : Front: C
  
  Channel positions                        : 1/0/0
  
  Sampling rate                            : 48000
  
  Sampling rate                            : 48.0 KHz
  
  Compression mode                         : Lossy
  
  Compression mode                         : Lossy
  
  Delay                                    : 718
  
  Delay                                    : 718ms
  
  Delay                                    : 718ms
  
  Delay                                    : 718ms
  
  Delay                                    : 00:00:00.718
  
  Delay, origin                            : Container
  
  Delay, origin                            : Container
  
  Language                                 : en
  
  Language                                 : English
  
  Language                                 : English
  
  Language                                 : en
  
  Language                                 : eng
  
  Language                                 : en
  
  Default                                  : Yes
  
  Default                                  : Yes
  
  Forced                                   : No
  
  Forced                                   : No

  What did I do wrong ? Do I have to re-encode it after the chunks get appended ? Is there some attribute I’m missing ? VP9 is supposed to reduce file sizes drastically.