অজগরটিতে একটি সংকেতে শব্দ যোগ করা

Question 1

এটিকে আরও বাস্তবসম্মত করার জন্য আমি পাইথনে যে সিমুলেট করছি তা প্রায় 100 টি বিন সংকেতটিতে কিছু এলোমেলো শব্দ যোগ করতে চাই।

একটি বেসিক স্তরে, আমার প্রথম চিন্তাটি বিন দ্বারা বিন হয়ে যাওয়া এবং কেবল একটি নির্দিষ্ট পরিসরের মধ্যে একটি এলোমেলো সংখ্যা তৈরি করা এবং সংকেত থেকে এটি যোগ বা বিয়োগ করা উচিত।

আমি আশা করছিলাম (যেহেতু এটি অজগর) এটি অদ্ভুত বা কোনও কিছুর মাধ্যমে আরও কিছু বুদ্ধিমান উপায় হতে পারে। (আমি অনুমান করি যে গাউসীয় বিতরণ থেকে আদর্শভাবে অঙ্কিত এবং প্রতিটি বিনের সাথে যুক্ত করা আরও ভাল হবে))

কোন জবাব আগাম ধন্যবাদ।

আমি কেবল আমার কোড পরিকল্পনা করার পর্যায়ে এসেছি, সুতরাং আমার কাছে দেখানোর মতো কিছুই নেই। আমি কেবল ভাবছিলাম যে শব্দটি উত্পন্ন করার আরও একটি পরিশীলিত উপায় হতে পারে।

আউটপুট শর্তাবলী, আমার যদি নিম্নলিখিত মানগুলির সাথে 10 টি বিন থাকে:

বিন 1: 1 বিন 2: 4 বিন 3: 9 বিন 4: 16 বিন 5: 25 বিন 6: 25 বিন 7: 16 বিন 8: 9 বিন 9: 4 বিন 10: 1

আমি কেবল ভাবলাম যে এমন কোনও পূর্বনির্ধারিত ফাংশন আছে যা আমাকে এমন কিছু দেওয়ার জন্য শব্দ যোগ করতে পারে:

বিন 1: 1.13 বিন 2: 4.21 বিন 3: 8.79 বিন 4: 16.08 বিন 5: 24.97 বিন 6: 25.14 বিন 7: 16.22 বিন 8: 8.90 বিন 9: 4.02 বিন 10: 0.91

যদি তা না হয় তবে আমি কেবল বিন-বাই-বিন যাব এবং প্রত্যেকটির গাওসিয়ান বিতরণ থেকে নির্বাচিত একটি সংখ্যা যুক্ত করব।

ধন্যবাদ.

এটি আসলে একটি রেডিও টেলিস্কোপ থেকে একটি সংকেত যা আমি অনুকরণ করছি। আমি শেষ পর্যন্ত আমার সিমুলেশনের শব্দ অনুপাতের সংকেতটি বেছে নিতে সক্ষম হতে চাই।

Question 2

আপনি একটি শব্দের অ্যারে তৈরি করতে পারেন এবং এটি আপনার সিগন্যালে যুক্ত করতে পারেন

import numpy as np

noise = np.random.normal(0,1,100)

# 0 is the mean of the normal distribution you are choosing from
# 1 is the standard deviation of the normal distribution
# 100 is the number of elements you get in array noise

Question 3

... এবং যারা - আমার মত - তাদের অদ্ভুত শেখার বক্ররেখার খুব প্রথম দিকে,

import numpy as np
pure = np.linspace(-1, 1, 100)
noise = np.random.normal(0, 1, 100)
signal = pure + noise

Question 4

যারা এসএনআর এবং একটি সাধারণ এলোমেলো ভেরিয়েবলের মধ্যে সংযোগ তৈরি করার চেষ্টা করছেন তাদের জন্য :

[1] ${SNR} = \frac{P_\mathrm{signal}}{P_\mathrm{noise}}$ , যেখানে পি গড় শক্তি বলে মনে রাখা গুরুত্বপূর্ণ ।

বা ডিবিতে:
[২] $\mathrm{SNR_{dB}} = {P_\mathrm{signal,dB} - P_\mathrm{noise,dB}}$

এই ক্ষেত্রে, আমাদের ইতিমধ্যে একটি সংকেত রয়েছে এবং আমরা আমাদের একটি পছন্দসই এসএনআর দিতে শব্দ উত্পন্ন করতে চাই।

আপনি কী মডেলিং করছেন তার উপর নির্ভর করে শব্দের বিভিন্ন স্বাদ আসতে পারে , তবে একটি ভাল শুরু (বিশেষত এই রেডিও টেলিস্কোপের উদাহরণের জন্য) হলেন অ্যাডেটিভ হোয়াইট গাউসিয়ান নয়েস (এডাব্লুজিএন) । পূর্ববর্তী উত্তরে বর্ণিত হিসাবে, AWGN মডেল করতে আপনাকে আপনার মূল সিগন্যালে শূন্য-গড় গাউসিয়ান র্যান্ডম ভেরিয়েবল যুক্ত করতে হবে। এই র্যান্ডম ভেরিয়েবলের বৈকল্পিক গড় শব্দ শক্তিকে প্রভাবিত করবে ।

গাউসিয়ান এলোমেলো পরিবর্তনশীল এক্স এর জন্য, গড় শক্তি $E[X^2]$ , যা দ্বিতীয় মুহূর্ত হিসাবেও পরিচিত ,
[3] $E[X^2]=\mu^2+\sigma^2$

তাই সাদা শব্দের জন্য, $\mu=0$ এবং গড় শক্তি তখন বৈকল্পের সমান $\sigma^2$ ।

অজগরটিকে এটি মডেল করার সময় আপনি হয়
১ টি করতে পারেন একটি পছন্দসই এসএনআর এবং বিদ্যমান পরিমাপের একটি সেটের উপর ভিত্তি করে বৈকল্পিক গণনা করুন, যদি আপনি আপনার পরিমাপগুলি মোটামুটি ধারাবাহিক প্রশস্ততা মান রাখার প্রত্যাশা করেন তবে এটি কাজ করবে।
২. বিকল্প হিসাবে, আপনি রিসিভার শব্দের মতো কোনও কিছুর সাথে মিলের জন্য একটি পরিচিত স্তরে শব্দ শক্তি সেট করতে পারেন। দূরবীনকে ফাঁকা জায়গায় চিহ্নিত করে এবং গড় পাওয়ার গণনা করে রিসিভারের শব্দটি মাপা যায়।

যে কোনও উপায়ে, আপনার সিগন্যালে আপনি শব্দটি যুক্ত করেছেন এবং ডিবি ইউনিট নয়, লিনিয়ার স্পেসে গড় নেন তা নিশ্চিত করা গুরুত্বপূর্ণ।

একটি সিগন্যাল এবং প্লটের ভোল্টেজ, ওয়াটসে শক্তি এবং ডিবিতে শক্তি উত্পন্ন করার জন্য এখানে কিছু কোড রয়েছে:

# Signal Generation
# matplotlib inline

import numpy as np
import matplotlib.pyplot as plt

t = np.linspace(1, 100, 1000)
x_volts = 10*np.sin(t/(2*np.pi))
plt.subplot(3,1,1)
plt.plot(t, x_volts)
plt.title('Signal')
plt.ylabel('Voltage (V)')
plt.xlabel('Time (s)')
plt.show()

x_watts = x_volts ** 2
plt.subplot(3,1,2)
plt.plot(t, x_watts)
plt.title('Signal Power')
plt.ylabel('Power (W)')
plt.xlabel('Time (s)')
plt.show()

x_db = 10 * np.log10(x_watts)
plt.subplot(3,1,3)
plt.plot(t, x_db)
plt.title('Signal Power in dB')
plt.ylabel('Power (dB)')
plt.xlabel('Time (s)')
plt.show()

কাঙ্ক্ষিত এসএনআরের ভিত্তিতে এডাব্লুজিএন যুক্ত করার জন্য এখানে একটি উদাহরণ রয়েছে:

# Adding noise using target SNR

# Set a target SNR
target_snr_db = 20
# Calculate signal power and convert to dB 
sig_avg_watts = np.mean(x_watts)
sig_avg_db = 10 * np.log10(sig_avg_watts)
# Calculate noise according to [2] then convert to watts
noise_avg_db = sig_avg_db - target_snr_db
noise_avg_watts = 10 ** (noise_avg_db / 10)
# Generate an sample of white noise
mean_noise = 0
noise_volts = np.random.normal(mean_noise, np.sqrt(noise_avg_watts), len(x_watts))
# Noise up the original signal
y_volts = x_volts + noise_volts

# Plot signal with noise
plt.subplot(2,1,1)
plt.plot(t, y_volts)
plt.title('Signal with noise')
plt.ylabel('Voltage (V)')
plt.xlabel('Time (s)')
plt.show()
# Plot in dB
y_watts = y_volts ** 2
y_db = 10 * np.log10(y_watts)
plt.subplot(2,1,2)
plt.plot(t, 10* np.log10(y_volts**2))
plt.title('Signal with noise (dB)')
plt.ylabel('Power (dB)')
plt.xlabel('Time (s)')
plt.show()

এবং একটি পরিচিত শব্দ শক্তি ভিত্তিতে AWGN যুক্ত করার জন্য এখানে একটি উদাহরণ রয়েছে:

# Adding noise using a target noise power

# Set a target channel noise power to something very noisy
target_noise_db = 10

# Convert to linear Watt units
target_noise_watts = 10 ** (target_noise_db / 10)

# Generate noise samples
mean_noise = 0
noise_volts = np.random.normal(mean_noise, np.sqrt(target_noise_watts), len(x_watts))

# Noise up the original signal (again) and plot
y_volts = x_volts + noise_volts

# Plot signal with noise
plt.subplot(2,1,1)
plt.plot(t, y_volts)
plt.title('Signal with noise')
plt.ylabel('Voltage (V)')
plt.xlabel('Time (s)')
plt.show()
# Plot in dB
y_watts = y_volts ** 2
y_db = 10 * np.log10(y_watts)
plt.subplot(2,1,2)
plt.plot(t, 10* np.log10(y_volts**2))
plt.title('Signal with noise')
plt.ylabel('Power (dB)')
plt.xlabel('Time (s)')
plt.show()

Question 5

যারা পান্ডাস ডেটাফ্রেমে বা এমনকি একটি নাম্পার নাদারের মধ্যে লোড বহুমাত্রিক ডেটাসেটে শব্দ যোগ করতে চান তাদের উদাহরণ এখানে:

import pandas as pd
# create a sample dataset with dimension (2,2)
# in your case you need to replace this with 
# clean_signal = pd.read_csv("your_data.csv")   
clean_signal = pd.DataFrame([[1,2],[3,4]], columns=list('AB'), dtype=float) 
print(clean_signal)
"""
print output: 
    A    B
0  1.0  2.0
1  3.0  4.0
"""
import numpy as np 
mu, sigma = 0, 0.1 
# creating a noise with the same dimension as the dataset (2,2) 
noise = np.random.normal(mu, sigma, [2,2]) 
print(noise)

"""
print output: 
array([[-0.11114313,  0.25927152],
       [ 0.06701506, -0.09364186]])
"""
signal = clean_signal + noise
print(signal)
"""
print output: 
          A         B
0  0.888857  2.259272
1  3.067015  3.906358
"""

Question 6

বাস্তব জীবনে আপনি সাদা শব্দ সঙ্গে একটি সংকেত অনুকরণ করতে ইচ্ছুক। আপনার সিগন্যাল এলোমেলো পয়েন্টগুলিতে যুক্ত করা উচিত যা সাধারণ গাউসীয় বিতরণ করে। যদি আমরা এমন কোনও ডিভাইস সম্পর্কে কথা বলি যা ইউনিট / এসকিউআরটি (এইচজেড) এ দেওয়া সংবেদনশীলতা রয়েছে তবে আপনাকে এটি থেকে আপনার পয়েন্টগুলির স্ট্যান্ডার্ড বিচ্যুতিটি তৈরি করতে হবে। এখানে আমি "হোয়াইট_নয়েজ" ফাংশন দিচ্ছি যা এটি আপনার জন্য করে, একটি বাকী একটি কোড প্রদর্শন এবং এটি যা করা উচিত তা যদি তা পরীক্ষা করে।

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

"""
parameters: 
rhp - spectral noise density unit/SQRT(Hz)
sr  - sample rate
n   - no of points
mu  - mean value, optional

returns:
n points of noise signal with spectral noise density of rho
"""
def white_noise(rho, sr, n, mu=0):
    sigma = rho * np.sqrt(sr/2)
    noise = np.random.normal(mu, sigma, n)
    return noise

rho = 1 
sr = 1000
n = 1000
period = n/sr
time = np.linspace(0, period, n)
signal_pure = 100*np.sin(2*np.pi*13*time)
noise = white_noise(rho, sr, n)
signal_with_noise = signal_pure + noise

f, psd = signal.periodogram(signal_with_noise, sr)

print("Mean spectral noise density = ",np.sqrt(np.mean(psd[50:])), "arb.u/SQRT(Hz)")

plt.plot(time, signal_with_noise)
plt.plot(time, signal_pure)
plt.xlabel("time (s)")
plt.ylabel("signal (arb.u.)")
plt.show()

plt.semilogy(f[1:], np.sqrt(psd[1:]))
plt.xlabel("frequency (Hz)")
plt.ylabel("psd (arb.u./SQRT(Hz))")
#plt.axvline(13, ls="dashed", color="g")
plt.axhline(rho, ls="dashed", color="r")
plt.show()

Question 7

উপরে দুর্দান্ত উত্তর। আমার সম্প্রতি সিমুলেটেড ডেটা তৈরি করার দরকার হয়েছিল এবং এটি ব্যবহার করে আমি অবতরণ করেছি। ক্ষেত্রে ভাগ করে নেওয়া অন্যকেও সহায়ক,

import logging
__name__ = "DataSimulator"
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

import numpy as np
import pandas as pd

def generate_simulated_data(add_anomalies:bool=True, random_state:int=42):
    rnd_state = np.random.RandomState(random_state)
    time = np.linspace(0, 200, num=2000)
    pure = 20*np.sin(time/(2*np.pi))

    # concatenate on the second axis; this will allow us to mix different data 
    # distribution
    data = np.c_[pure]
    mu = np.mean(data)
    sd = np.std(data)
    logger.info(f"Data shape : {data.shape}. mu: {mu} with sd: {sd}")
    data_df = pd.DataFrame(data, columns=['Value'])
    data_df['Index'] = data_df.index.values

    # Adding gaussian jitter
    jitter = 0.3*rnd_state.normal(mu, sd, size=data_df.shape[0])
    data_df['with_jitter'] = data_df['Value'] + jitter

    index_further_away = None
    if add_anomalies:
        # As per the 68-95-99.7 rule(also known as the empirical rule) mu+-2*sd 
        # covers 95.4% of the dataset.
        # Since, anomalies are considered to be rare and typically within the 
        # 5-10% of the data; this filtering
        # technique might work 
        #for us(https://en.wikipedia.org/wiki/68%E2%80%9395%E2%80%9399.7_rule)
        indexes_furhter_away = np.where(np.abs(data_df['with_jitter']) > (mu + 
         2*sd))[0]
        logger.info(f"Number of points further away : 
        {len(indexes_furhter_away)}. Indexes: {indexes_furhter_away}")
        # Generate a point uniformly and embed it into the dataset
        random = rnd_state.uniform(0, 5, 1)
        data_df.loc[indexes_furhter_away, 'with_jitter'] +=  
        random*data_df.loc[indexes_furhter_away, 'with_jitter']
    return data_df, indexes_furhter_away

Question 8

মতলব ফাংশনের সাথে সমান AWGN

def awgn(sinal):
    regsnr=54
    sigpower=sum([math.pow(abs(sinal[i]),2) for i in range(len(sinal))])
    sigpower=sigpower/len(sinal)
    noisepower=sigpower/(math.pow(10,regsnr/10))
    noise=math.sqrt(noisepower)*(np.random.uniform(-1,1,size=len(sinal)))
    return noise