RML2016.10a数据集画星座图、频域图、时域图

最新推荐文章于 2024-06-03 13:31:43 发布
最新推荐文章于 2024-06-03 13:31:43 发布
阅读量1k 收藏 22
点赞数 9
文章标签： 人工智能
原文链接：https://github.com/JoshiShamika/Deep-learning-for-Modulation-Recognition-on-RML2016.10a_dict-dataset
版权

原文链接：JoshiShamika/Deep-learning-for-Modulation-Recognition-on-RML2016.10a_dict-dataset (github.cs我对原文代码的修改：

import pickle
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

with open("2016/RML2016.10a_dict.pkl", 'rb') as file:
    Xd = pickle.load(file, encoding='bytes')


def AM_SSB():
    # Loading the dataset

        # Ploting for AM-SSB in I/Q plane
        snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
        X1 = []
        Y1 = []
        lbl = []
        str = b'AM-SSB'
        for mod in mods:
            for snr in snrs:
                if (mod == str and snr == 16):
                    test = Xd[(mod, snr)]
                    X1.append(Xd[(mod, snr)])
                    for i in range(Xd[(mod, snr)].shape[0]):
                        lbl.append((mod, snr))
                        Y1.append([test[0] + 1j * test[1]])
        X1 = np.vstack(X1)
        Y1 = np.vstack(Y1)

        df = pd.DataFrame(lbl, columns=["mod", "snr"])
        df['snr'].value_counts()
        ind = []
        for i in range(0, df.shape[0]):
            if (df['snr'][i] == 16):
                ind.append(i)

        for i in range(0, 10, 1):
            x = X1[i][0]
            y = X1[i][1]
            fig = plt.figure()
            plt.scatter(x, y, c='blue', label=i)
            plt.xlabel("I")
            plt.ylabel("Q")
            plt.title("Data representation variance in AM-SSB SNR 16")
            plt.legend()
            plt.show()
        print('point1')
        plt.plot(Xd[b'AM-SSB', 4][2, 0])
        plt.plot(Xd[b'AM-SSB', 8][2, 0])
        plt.xlabel("Time")
        plt.ylabel("Amplitude")
        plt.title("AM-SSB Time Plot")
        plt.grid(axis='both')
        plt.show()

        print('point2')
        data = Xd[b'AM-SSB', 4][2, 0]
        power_sp = np.abs(np.fft.fft(data)) ** 2
        time_step = 1
        fre = np.fft.fftfreq(len(power_sp), time_step)
        idx = np.argsort(fre)
        plt.plot(fre[idx], power_sp[idx])
        plt.xlabel("Frequency")
        plt.ylabel("Power Spectrum")
        plt.title("AM-SSB Power Spectrum")
        plt.grid(axis='both')
        plt.show()

        print('point3')


def _8PSK():
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'8PSK'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in 8PSK SNR 16")
        plt.legend()
        plt.show()

    # Ploting 8PSK in time domain
    plt.plot(Xd[b'8PSK', 4][2, 0])
    plt.plot(Xd[b'8PSK', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("8PSK Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'8PSK', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("8PSK Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def AM_DSB():
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'AM-DSB'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in AM-DSB SNR 16")
        plt.legend()
        plt.show()

    # Ploting AM-DSB in time domain
    plt.plot(Xd[b'AM-DSB', 4][2, 0])
    plt.plot(Xd[b'AM-DSB', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("AM-DSB Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'AM-DSB', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("AM-DSB Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def CPFSK():
    # Ploting for CPFSK in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'CPFSK'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in CPFSK SNR 16")
        plt.legend()
        plt.show()

    # Ploting CPFSK in time domain
    plt.plot(Xd[b'CPFSK', 4][2, 0])
    plt.plot(Xd[b'CPFSK', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("CPFSK Time Plot")
    plt.grid( axis='both')
    plt.show()

    data = Xd[b'CPFSK', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("CPFSK Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def BPSK():
    # Ploting for BPSK in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'BPSK'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in BPSK SNR 16")
        plt.legend()
        plt.show()

    # Ploting BPSK in time domain
    plt.plot(Xd[b'BPSK', 4][2, 0])
    plt.plot(Xd[b'BPSK', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("BPSK Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'BPSK', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("BPSK Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def PAM4():
    # Ploting for PAM4 in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'PAM4'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in PAM4 SNR 16")
        plt.legend()
        plt.show()

    # Ploting PAM4 in time domain
    plt.plot(Xd[b'PAM4', 4][2, 0])
    plt.plot(Xd[b'PAM4', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("PAM4 Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'PAM4', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("PAM4 Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def QAM64():
    # Ploting for QAM64 in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'QAM64'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in QAM64 SNR 16")
        plt.legend()
        plt.show()

    # Ploting for QAM64 in time domain
    plt.plot(Xd[b'QAM64', 4][6, 0])
    plt.plot(Xd[b'QAM64', 4][7, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("QAM64 Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'QAM64', 4][6, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("QAM64 Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def GFSK():
    # Ploting for GFSK in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'GFSK'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in GFSK SNR 16")
        plt.legend()
        plt.show()

    # Ploting GFSK in time domain
    plt.plot(Xd[b'GFSK', 4][2, 0])
    plt.plot(Xd[b'GFSK', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("GFSK Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'GFSK', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("GFSK Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def QAM16():
    # Ploting for QAM16 in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'QAM16'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in QAM16 SNR 16")
        plt.legend()
        plt.show()

    # Ploting for QAM16 in time domain
    plt.plot(Xd[b'QAM16', 4][2, 0])
    plt.plot(Xd[b'QAM16', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("QAM16 Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'QAM16', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("QAM16 Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def QPSK():
    # Ploting for QPSK in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'QPSK'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in QPSK SNR 16")
        plt.legend()
        plt.show()

    # Ploting for QPSK in time domain
    plt.plot(Xd[b'QPSK', 4][2, 0])
    plt.plot(Xd[b'QPSK', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("QPSK Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'QPSK', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("QPSK Power Spectrum")
    plt.grid(axis='both')
    plt.show()


def WBFM():
    # Ploting for WBFM in I/Q plane
    snrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])
    X1 = []
    Y1 = []
    lbl = []
    str = b'WBFM'
    for mod in mods:
        for snr in snrs:
            if (mod == str and snr == 16):
                test = Xd[(mod, snr)]
                X1.append(Xd[(mod, snr)])
                for i in range(Xd[(mod, snr)].shape[0]):
                    lbl.append((mod, snr))
                    Y1.append([test[0] + 1j * test[1]])
    X1 = np.vstack(X1)
    Y1 = np.vstack(Y1)
    print(mods)
    print(snrs)

    df = pd.DataFrame(lbl, columns=["mod", "snr"])
    df['snr'].value_counts()
    ind = []
    for i in range(0, df.shape[0]):
        if (df['snr'][i] == 16):
            ind.append(i)

    for i in range(0, 10, 1):
        x = X1[i][0]
        y = X1[i][1]
        fig = plt.figure()
        plt.scatter(x, y, c='blue', label=i)
        plt.xlabel("I")
        plt.ylabel("Q")
        plt.title("Data representation variance in WBFM SNR 16")
        plt.legend()
        plt.show()

    # Ploting for WBFM in time domain
    plt.plot(Xd[b'WBFM', 4][2, 0])
    plt.plot(Xd[b'WBFM', 8][2, 0])
    plt.xlabel("Time")
    plt.ylabel("Amplitude")
    plt.title("WBFM Time Plot")
    plt.grid(axis='both')
    plt.show()

    data = Xd[b'WBFM', 4][2, 0]
    power_sp = np.abs(np.fft.fft(data)) ** 2
    time_step = 1
    fre = np.fft.fftfreq(len(power_sp), time_step)
    idx = np.argsort(fre)
    plt.plot(fre[idx], power_sp[idx])
    plt.xlabel("Frequency")
    plt.ylabel("Power Spectrum")
    plt.title("WBFM Power Spectrum")
    plt.grid(axis='both')
    plt.show()


if __name__ == '__main__':
    WBFM()

画出来的图示例：

Chai.yx
关注
  • 9
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
读取rml2016.10a数据集
qq_42344181的博客
12-06 3440
读取rml2016.10a数据集
RML2016.10a数据集读取和处理
热门推荐
QAQIknow的博客
12-22 3万+
读取文件 由于RML2016.10a_dict.pkl的编码是latin-1（以此为例，其他的也可以类似，实在查不到，也可以最笨的方法，一个个编码格式试出来= =） 读取代码 with open(r'**路径**', 'rb') as p_f: s = pickle.load(p_f,encoding="latin-1") 读取细节 举个例子，看你要读取什么，根据自己要求读取 for i in s.keys(): # print(i,s[i]) # print(s[i]) # 输
论文翻译七：Adversarial Transfer Learning for Deep Learning Based Automatic Modulation Classification
进击者笔记
12-21 1060
30天挑战翻译100篇论文 坚持不懈，努力改变，在翻译中学习，在学习中改变，在改变中成长… Adversarial Transfer Learning for Deep Learning Based Automatic Modulation Classification 基于对抗学习的深度学习自动调制分类 Ke Bu , Yuan He , Xiaojun Jing , and Jindong Han 摘要—自动调制分类有助于许多重要的信号处理应用。 最近，深度学习模型已在调制识别中采用，该模型优于基于手工
RML2016.10a （CNN、LSTM、CNN-LSTM、CNN-LSTM-Multi-head-attention, TensorFlow）
qq_40999533的博客
03-20 377
RML2016.10a （CNN、LSTM、CNN-LSTM、CNN-LSTM-Multi-head-attention, TensorFlow） 包含所有数据和代码，支持一键运行（jupyter）
调制信号识别数据集RML2016.10A
04-11
调制信号识别数据集RML2016.10A
RML2016.10a-数据集
03-11
This is an open-source data set from deepsig.ai. AM-SSB.csv AM-DSB.csv BPSK.csv 8PSK.csv CPFSK.csv GFSK.csv PAM4.csv QAM16.csv QAM64.csv QPSK.csv WBFM.csv
RML2016.10a_dict.pkl
02-02
深度学习调制分类数据集
RML2016.10a数据集生成环境配置
weixin_44175715的博客
10-13 3338
1.前言 为了修改RML2016.10a数据集的一些参数，需要自己配置gnuradio的开发环境，尤其是gr-mapper和gr-mediatools的两个插件很麻烦。之前很多人写过了具体怎么配置了，这里记一个anaconda环境下环境配置的方法。 2.主要流程 2.1 安装虚拟机 这步略过吧，VMware创建虚拟机直接默认设置，根据自己机器改一下硬件设置就好，没有镜像的可以去下面的网址下需要的版本（这篇文章用的是18.04，之前试过20.04但是记不得具体有哪些坑了）NJU Mirrorhttps
0325_final project_preparation_dataset RML2016a
weixin_42216631的博客
03-26 676
数据集介绍 11种调制方式 8种数字调制方式，3种模拟调制方式 数字： BPSK QPSK 8PSK 16QAM 64QAM BFSK CPFSK PAM4 模拟： WB-FM AM-SSB AM-DSB 11种调制方式的信噪比在-20dB到20dB之间 一半用来训练网络，一半用来测试 ...
RML2016.10a_dict.zip
12-17
本案例针对RML2016.10a_dict数据集并利用VT-CNN2 Mod-Rec Network卷积神经网络对信号实现自动调制方式识别，使用卷积神经网络在图像处理问题中的位移不变性特点，来解决调制识别的问题，使用网络结构来学习匹配...
rml-reference
06-24
很少能看到关于RML的东西，这个可是绝版哦
RML2016数据生成代码.rar
05-30
RML2016a数据集生成代码
强化学习——学习笔记3
qq_52302919的博客
05-29 1570
先上图：在上述流程图中所说的Q表即为下表：假设我们在玩一个小游戏，该游戏有上下左右不同的动作，同时也会有不同的状态，比如游戏结束等。Q表也可以称为状态-价值函数QsaQ(s,a)Qsa：这个表格的每一行代表每个 state上述例子中的游戏结束等，每一列代表每个 action上述例子中的上下左右，表格的数值就是在各个 state 下采取各个 action 时能够获得的最大的未来期望奖励。
pytorch学习笔记5
drarad的博客
06-02 1219
前向钩子（forward hook）在模块的前向传播开始时触发，前向后钩子（forward pre-hook）在前向传播之前触发，反向钩子（backward hook）在反向传播过程中触发。总结来说，钩子提供了一种在 PyTorch 模型的执行过程中插入自定义代码的方法，使得用户可以灵活地调试、监控和扩展模型的功能。作用: 这是一个内部的 C 语言指针，指向张量在底层库（通常是 C++ 实现的 PyTorch 核心）中的具体数据结构。这些钩子可以在张量的梯度计算之前或之后执行自定义的操作。
AI推文神器，绘唐ai，文刻创作出品，sdmj二合一虹猫
2401_84285498的博客
05-28 741
然而，值得注意的是，AI推文神器虽然能够生成高质量的推文内容，但仍然需要人类的审查和修改。因为它虽然能够模仿人类的写作风格，但仍然无法完全理解人类的情感和语境，因此在使用AI推文神器时，人类编辑和审阅的角色仍然十分重要，以确保推文的准确性和符合品牌形象。AI推文神器的工作原理是通过自然语言处理和机器学习算法，将用户输入的关键词、主题或简要描述转化为语义信息，然后结合相关数据和模型，生成相应的推文内容。它通过分析大量的文字和数据，学习并模仿人类的写作风格和推文技巧，从而能够生成独特、有吸引力的推文内容。
AI Agent：人类工作范式的颠覆者还是人机协作新范式？
Baihai_IDP的博客
05-29 803
生成式 AI 只是人工智能发展的开端，未来可能会出现更先进的 AI 智能体系统（AI Agent），我们应当重视 Andrew Ng（译者注：Andrew Ng 是斯坦福大学计算机科学系和电气工程系的客座教授，曾任斯坦福人工智能实验室主任。作者相信人工智能的未来必将呈现出更智能、更自主的 AI Agent 形态。但是 AI Agent 强调的是综合智能，包括但不限于决策制定、环境交互和跨领域的知识应用，这样的智能系统能够适应更复杂的任务需求，并在与人的交流合作中展现出更强的灵活性和实用性。
Python热重载调试新利器
最新发布
weixin_53707653的博客
06-03 316
Reloading是一个Python工具库，它让我们可以在每次迭代之前从源代码中重新加载（或函数）而不丢失任何当前已执行过程。该工具对于在深度学习模型训练期间编辑源代码尤其好用，它让我们可以添加日志记录、打印统计数据或保存模型，而无需重新启动训练。
llama-factory微调大模型
05-31 318
微调或者全量调大语言模型，还包括deepseek,想找个快速的微调教程，网上暂时没有。原理：搭建环境太累了，还是docker环境镜像简单快捷。如果用本身的会自动从huggingface下载，2、拉去LLAMA-factory repo。3、要根据自己的目录调整启动镜像。这下不了（也没有提示）
基于pytorch读取rml2016.10a数据集的标签，并打印
05-24
以下是基于PyTorch读取RML2016.10a数据集标签并打印的代码： ```python import numpy as np import torch.utils.data as data # 读取RML2016.10a数据集的标签 def read_labels(file_path): with open(file_path, 'rb') as f: labels = np.load(f) return labels class RMLDataset(data.Dataset): def __init__(self, file_path): self.labels = read_labels(file_path) def __getitem__(self, index): label = self.labels[index] return label def __len__(self): return len(self.labels) # 加载数据集 dataset = RMLDataset('RML2016.10a_dict.pkl') # 打印标签 for label in dataset: print(label) ``` 这段代码首先定义了一个`read_labels`函数，用于从文件中读取RML2016.10a数据集的标签。然后定义了一个`RMLDataset`类，继承自PyTorch的`data.Dataset`，用于加载数据集并返回标签。最后，根据数据集创建一个实例并遍历标签进行打印。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值