├── README.md ├── array_respones.m ├── calculateRate_WB_SU.m ├── generate_channel_H.m ├── generate_channel_H_LIS.m ├── m054_train_v0.m ├── non_overlapbeam.m ├── stopIfAccuracyNotImproving.m ├── train_ChannelNet.m └── wideband_channel_extractDOAs.m /README.md: -------------------------------------------------------------------------------- 1 | # deepChannelLearning4RIS 2 | Channel Estimation for Reconfigurable Intelligent Surface via Deep Learning 3 | MATLAB Codes for the paper: 4 | 5 | A. M. Elbir, A Papazafeiropoulos, P. Kourtessis, and S. Chatzinotas, "Deep Channel Learning For Large Intelligent Surfaces Aided mm-Wave Massive MIMO Systems", IEEE Wireless Communications Letters, in press, 2020. 6 | 7 | Prepared by Ahmet M. Elbir, 2020, Please cite the above work if you use this code. e-mail me for questions via: ahmetmelbir@gmail.com 8 | 9 | This includes the data generation for the training dataset and model training. 10 | 11 | This document is prepared upon request from the colleagues. The code includes several unnecesary parts. I will update it soon. 12 | -------------------------------------------------------------------------------- /array_respones.m: -------------------------------------------------------------------------------- 1 | function a=array_respones(azimuth,N,d,lamada) 2 | a=[]; 3 | for i=1:length(azimuth) 4 | a=[a (sqrt(1/N)*exp(1i*[0:N-1]*2*pi*d*sin(azimuth(i))/lamada)).']; 5 | end -------------------------------------------------------------------------------- /calculateRate_WB_SU.m: -------------------------------------------------------------------------------- 1 | function [Rate] = calculateRate_WB_SU(Frf_CNN,Fbb_CNN,Wrf_CNN,Wbb_CNN,H,snr) 2 | Rate = 0; 3 | [Nr,Nt,~,Num_bands] = size(H); 4 | Ns = size(Fbb_CNN,2); 5 | for b = 1:Num_bands 6 | Wt = sqrt(1)*Wrf_CNN*Wbb_CNN(:,:,b); 7 | Ft = sqrt(1)*Frf_CNN*Fbb_CNN(:,:,b); 8 | % C = inv(Wt'*Wt + 0.0001*eye(size(Wt,2)))*Wt'; 9 | % Rate = Rate + real( log2(det(eye(Ns) + snr*C*H(:,:,1,b)*(Ft*Ft')*H(:,:,1,b)'*Wt )))/Num_bands; 10 | Rate = Rate + real(helperComputeSpectralEfficiency(H(:,:,1,b),Ft,Wt,Ns,snr) )/(Num_bands); 11 | end 12 | -------------------------------------------------------------------------------- /generate_channel_H.m: -------------------------------------------------------------------------------- 1 | % wideband_channel_extractDOAs.m 2 | % Today 3 | % 10:13 AM 4 | % 5 | % You edited an item 6 | % Objective C 7 | % wideband_channel_extractDOAs.m 8 | % Last week 9 | % Nov 11 10 | % 11 | % You uploaded an item 12 | % Objective C 13 | % wideband_channel_extractDOAs.m 14 | function [H, At, Ar, DOA, AOA, BETA, delay] = generate_channel_H(Nt,Nr,L,fs,fc,M,Num_users) 15 | % clear all; 16 | % Nt=64; %trasmit antennas 17 | % Nr=1; % receive antennas 18 | % L=3; %paths 19 | % fc=60*10^9; %carrier frequency 20 | % fs=3.5*10^9; % sampling frequency fs=2M(BW) 21 | % BW= 35*10^6; 22 | % M=3; 23 | % K=1; 24 | % Nt_rf=4; 25 | 26 | %%% path delay 27 | % delay_max = 20e-9; 28 | % delay = delay_max*rand(1,L); 29 | delay = [[1.78032951094980e-08,9.55821708146159e-09,7.35131305345536e-09,4.73002944592621e-09,3.13224555779004e-09,8.52959370256540e-09,3.91263028442759e-10,1.18337584383972e-08,8.14978983666684e-09,7.66654915622931e-10]]; 30 | 31 | lambda_c = 3e8/fc; % wavelength 32 | dt = lambda_c/2; 33 | dr = dt; 34 | H = zeros(Nr,Nt,Num_users,M); 35 | % C = zeros(Nt,Nt,Num_users,M); 36 | % Ch = zeros(Nt,Nt,Num_users,M); 37 | 38 | for u=1:1:Num_users 39 | beta(1:L) = exp(1i*2*pi*rand(1,L)); 40 | % beta(1:L) = sqrt(1/2)*(randn(1,L)+1i*randn(1,L)); % of var 1. 41 | % beta(1:L) = ones(1,L); 42 | 43 | %%% DoA 44 | DoA_index = non_overlapbeam(Nt,L,1); 45 | set_t = (-(Nt-1)/2:1:(Nt-1)/2)/(Nt/2); 46 | DoA = ((2/Nt)*rand(1,L) - 1/Nt) + set_t(DoA_index); 47 | %% AoA 48 | % AoA_index = non_overlapbeam(Nr,L,1); 49 | % set_r = (-(Nr-1)/2:1:(Nr-1)/2)/(Nr/2); 50 | % AoA = ((2/Nr)*rand(1,L) - 1/Nr) + set_r(AoA_index); 51 | AoA = 2*rand(1,L) - 1; 52 | 53 | 54 | for m = 1 : M 55 | % f = fc; 56 | f(m) = fc + fs/M*(m-1-(M-1)/2); 57 | lambda(m) = 3e8/f(m); 58 | for l = 1 : L 59 | At(:,l,u) = array_respones(DoA(l),Nt,dt,lambda(1)); 60 | Ar(:,l,u) = array_respones(AoA(l),Nr,dr,lambda(1)); 61 | % H(:,:,u,m) = H(:,:,u,m) + sqrt(Nt*Nr)* Ar(:,l,u)* At(:,l,u)'; 62 | H(:,:,u,m) = H(:,:,u,m) + beta(l)*exp(-1i*2*pi*f(m)*delay(l))* Ar(:,l,u)* At(:,l,u)'; 63 | % C(:,:,u,m) = C(:,:,u,m) + (Nt*Nr)*At(:,l,u)* At(:,l,u)'; 64 | % norm(C(:,:,u,m) - H(:,:,u,m)'*H(:,:,u,m)) 65 | % Ch(:,:,u,m) = Ch(:,:,u,m) + H(:,:,u,m)'*H(:,:,u,m); 66 | end 67 | H(:,:,u,m) = sqrt(Nt*Nr)*H(:,:,u,m); 68 | % H(:,:,u,m) = H(:,:,u,m); 69 | % C(:,:,u,m) = (Nt*Nr)*C(:,:,u,m); 70 | 71 | end 72 | 73 | % norm(C(:,:,u,m) - H(:,:,u,m)'*H(:,:,u,m)) 74 | 75 | % norm(C(:,:,u,m)) - norm(H(:,:,u,m)'*H(:,:,u,m)) 76 | 77 | %% collect data 78 | DOA(u,:) = DoA; 79 | AOA(u,:) = AoA; 80 | BETA(u,:) = beta; 81 | end -------------------------------------------------------------------------------- /generate_channel_H_LIS.m: -------------------------------------------------------------------------------- 1 | % wideband_channel_extractDOAs.m 2 | % Today 3 | % 10:13 AM 4 | % 5 | % You edited an item 6 | % Objective C 7 | % wideband_channel_extractDOAs.m 8 | % Last week 9 | % Nov 11 10 | % 11 | % You uploaded an item 12 | % Objective C 13 | % wideband_channel_extractDOAs.m 14 | function [H, At, Ar, DOA, AOA, BETA, delay] = generate_channel_H_LIS(Nt,Nr,L,fs,fc,M,Num_users) 15 | % clear all; 16 | % Nt=64; %trasmit antennas 17 | % Nr=1; % receive antennas 18 | % L=3; %paths 19 | % fc=60*10^9; %carrier frequency 20 | % fs=3.5*10^9; % sampling frequency fs=2M(BW) 21 | % BW= 35*10^6; 22 | % M=3; 23 | % K=1; 24 | % Nt_rf=4; 25 | 26 | %%% path delay 27 | % delay_max = 20e-9; 28 | % delay = delay_max*rand(1,L); 29 | delay = [[1.78032951094980e-08,9.55821708146159e-09,7.35131305345536e-09,4.73002944592621e-09,3.13224555779004e-09,8.52959370256540e-09,3.91263028442759e-10,1.18337584383972e-08,8.14978983666684e-09,7.66654915622931e-10]]; 30 | 31 | lambda_c = 3e8/fc; % wavelength 32 | dt = lambda_c/2; 33 | dr = dt; 34 | H = zeros(Nr,Nt,Num_users,M); 35 | % C = zeros(Nt,Nt,Num_users,M); 36 | % Ch = zeros(Nt,Nt,Num_users,M); 37 | 38 | for u=1:1:Num_users 39 | beta(1:L) = exp(1i*2*pi*rand(1,L)); 40 | % beta(1:L) = sqrt(1/2)*(randn(1,L)+1i*randn(1,L)); % of var 1. 41 | % beta(1:L) = ones(1,L); 42 | 43 | %%% DoA 44 | % DoA_index = non_overlapbeam(Nt,L,1); 45 | % set_t = (-(Nt-1)/2:1:(Nt-1)/2)/(Nt/2); 46 | % DoA = ((2/Nt)*rand(1,L) - 1/Nt) + set_t(DoA_index); 47 | %% AoA 48 | % AoA_index = non_overlapbeam(Nr,L,1); 49 | % set_r = (-(Nr-1)/2:1:(Nr-1)/2)/(Nr/2); 50 | % AoA = ((2/Nr)*rand(1,L) - 1/Nr) + set_r(AoA_index); 51 | AoA = 2*rand(1,L) - 1; 52 | 53 | 54 | for m = 1 : M 55 | % f = fc; 56 | f(m) = fc + fs/M*(m-1-(M-1)/2); 57 | lambda(m) = 3e8/f(m); 58 | for l = 1 : L 59 | At(:,l,u) = 0; 60 | Ar(:,l,u) = array_respones(AoA(l),Nr,dr,lambda(1)); 61 | % H(:,:,u,m) = H(:,:,u,m) + sqrt(Nt*Nr)* Ar(:,l,u)* At(:,l,u)'; 62 | H(:,:,u,m) = H(:,:,u,m) + beta(l)*exp(-1i*2*pi*f(m)*delay(l))* Ar(:,l,u); 63 | % C(:,:,u,m) = C(:,:,u,m) + (Nt*Nr)*At(:,l,u)* At(:,l,u)'; 64 | % norm(C(:,:,u,m) - H(:,:,u,m)'*H(:,:,u,m)) 65 | % Ch(:,:,u,m) = Ch(:,:,u,m) + H(:,:,u,m)'*H(:,:,u,m); 66 | end 67 | H(:,:,u,m) = sqrt(Nt*Nr)*H(:,:,u,m); 68 | % H(:,:,u,m) = H(:,:,u,m); 69 | % C(:,:,u,m) = (Nt*Nr)*C(:,:,u,m); 70 | 71 | end 72 | 73 | % norm(C(:,:,u,m) - H(:,:,u,m)'*H(:,:,u,m)) 74 | 75 | % norm(C(:,:,u,m)) - norm(H(:,:,u,m)'*H(:,:,u,m)) 76 | 77 | %% collect data 78 | DOA(u,:) = 0; 79 | AOA(u,:) = AoA; 80 | BETA(u,:) = beta; 81 | end -------------------------------------------------------------------------------- /m054_train_v0.m: -------------------------------------------------------------------------------- 1 | % Multi-user channel estimation with reconfigurable intelligent surfaces via deep learning. 2 | % MATLAB Codes for the paper: A. M. Elbir, A Papazafeiropoulos, P. Kourtessis, 3 | % and S. Chatzinotas, "Deep Channel Learning For Large Intelligent Surfaces 4 | % Aided mm-Wave Massive MIMO Systems", IEEE Wireless Communications 5 | % Letters, in press, 2020. 6 | % Prepared by Ahmet M. Elbir, 2020, Please cite the above work if you use 7 | % this code. e-mail me for questions via: ahmetmelbir@gmail.com 8 | % This includes the data generation for the training dataset and model 9 | % training. 10 | 11 | 12 | clear all; 13 | % addpath('./AltMin/Narrowband'); 14 | % addpath('./TwoStage vs ZF vs ACE vs AS_final - two-bit'); 15 | % addpath(genpath('./AltMin')); 16 | % ----------------------------- System Parameters ------------------------- 17 | % Num_bands = 3; % number of subcarriers 18 | opts.Num_paths = 4; %Number of channel paths 19 | M = 64; % number of Tx antennas. 20 | % M2 = 2^8; 21 | L = 10; % number of LIS antennas. L=100; 22 | K = 8; % Number of users 23 | % T = 1024; 24 | Ns = 1; % number of data streams. 25 | % P = L; 26 | NtRF = 4;%opts.Ns*opts.Num_users; % number of PS at Tx. 27 | NrRF = 4;%opts.Ns; % number of PS at Rx. 28 | % Ns = NtRF/opts.Num_users; % number of PS per user 29 | opts.fc = 60*10^9; %carrier frequency 30 | opts.BW = 4*10^9; %bandwidth 31 | opts.fs = opts.BW; % sampling frequency fs=2M(BW) 32 | opts.selectOutputAsPhases = 1; 33 | opts.snr_param = [0]; % SNR dB. 34 | opts.Nreal = 30; % number of realizations. 35 | opts.Nchannels = 1; % number of channel matrices for the input data, make it 100 for better sampling the data space. 36 | opts.fixedUsers = 0; 37 | opts.fixedChannelGain = 0; 38 | % opts.generateNoisyChannels = 1; 39 | % opts.noiseLevelHdB_HB = [20 25 25]; % dB. 40 | opts.noiseLevelHdB_CE = [ 25 30 40 50]; % dB. 41 | opts.inputH = 1; 42 | opts.inputRy = 0; 43 | timeGenerate = tic; 44 | rng(4096); 45 | 46 | Num_paths = opts.Num_paths; 47 | Nch = opts.Nchannels; 48 | Nreal = opts.Nreal; 49 | N = Nreal*Nch*K; 50 | % X_HB = zeros(Num_bands*Nr,Nt,3,N); 51 | Z = repmat(struct('channel_dc',zeros(M,1,K)),1,N ); 52 | % Y_Temp = zeros(Num_users,Ns*(Nt + Nr)); 53 | snr = db2pow(opts.snr_param); 54 | % gamma = 1/(Nt*NtRF); 55 | % Mt = Nt; 56 | % Mr = Nr; 57 | % Xce = eye(Mt); 58 | F = dftmtx(M);% DFT_R = dftmtx(Nr); 59 | % Fce = DFT_T(:,1:M); 60 | % Wce = DFT_R(:,1:Mr); 61 | jjHB = 1; 62 | jjCE = 1; 63 | jjA2 = 1; 64 | X = eye(M); % pilot data. 65 | X2 = eye(M*L); 66 | V = eye(L); % reflect beamforming data. 67 | doaMismatchList = linspace(0,10,Nch); 68 | for nch = 1:Nch 69 | %% Generate channels 70 | % H. 71 | % if nch == 1 72 | % H, G. 73 | [H, At, Ar, DoA, AoA, beta, delay] = generate_channel_H(L,M,Num_paths,opts.fs,opts.fc,1,1); 74 | paramH(nch,1).At = At; 75 | paramH(nch,1).Ar = Ar; 76 | paramH(nch,1).DoA = DoA; 77 | paramH(nch,1).AoA = AoA; 78 | paramH(nch,1).beta = beta; 79 | % H LIS, G. 80 | [h_lis, At, Ar, DoA, AoA, beta, delay] = generate_channel_H_LIS(1,L,Num_paths,opts.fs,opts.fc,1,K); 81 | paramH_LIS(nch,1).At = At; 82 | paramH_LIS(nch,1).Ar = Ar; 83 | paramH_LIS(nch,1).DoA = DoA; 84 | paramH_LIS(nch,1).AoA = AoA; 85 | paramH_LIS(nch,1).beta = beta; 86 | % H DC. 87 | [h_dc, At, Ar, DoA, AoA, beta, delay] = generate_channel_H_LIS(1,M,Num_paths,opts.fs,opts.fc,1,K); 88 | paramH_DC(nch,1).At = At; 89 | paramH_DC(nch,1).Ar = Ar; 90 | paramH_DC(nch,1).DoA = DoA; 91 | paramH_DC(nch,1).AoA = AoA; 92 | paramH_DC(nch,1).beta = beta; 93 | % else 94 | % end 95 | %% TEST 96 | 97 | %% 98 | % cascaded channel. 99 | G = zeros(M,L,K); 100 | for kk = 1:K 101 | G(:,:,kk) = H* diag(h_lis(:,1,kk)); 102 | end 103 | 104 | % h_lis = h_lis/norm(h_lis(:)); G = G/norm(G(:)); h_dc = h_dc/norm(h_dc(:)); 105 | %% Channel estimation 106 | timeGenerate = tic; 107 | for nr = 1:Nreal 108 | snrIndex_CE = ceil(nr/(Nreal/size(opts.noiseLevelHdB_CE,2))); 109 | snrChannel = opts.noiseLevelHdB_CE(snrIndex_CE); 110 | % snrIndex_HB = ceil(nr/(Nreal/size(opts.noiseLevelHdB_HB,2))); 111 | % snrH_HB = opts.noiseLevelHdB_HB(snrIndex_HB); 112 | % X_wop = orth(1/sqrt(2)*(randn(M) + 1i*randn(M))); % data symbols. 113 | S = 1/sqrt(2)*(randn(K,M) + 1i*randn(K,M)); 114 | % X_wop = F(:,1:K)*S; %X_wop = X_wop/norm(X_wop); 115 | for kk = 1:K % number of users. 116 | y_dc(kk,:) = awgn( h_dc(:,1,kk)'*X, snrChannel,'measured' ); % direct channel data. 117 | % y_dc_wop(kk,:) = awgn( h_dc(:,1,kk)'*X_wop, snrChannel,'measured' ); 118 | h_dc_e(:,kk) = (y_dc(kk,:)*pinv(X))'; % direct channel LS. 119 | % nmse_d = rms(vec( h_d_e(:,k) - h_d(:,1,k) ) ) 120 | vG = []; h_dc_kron = []; 121 | for p = 1:L % for each LIS components. estimate cascaded channel 122 | v = V(:,p); 123 | vG = [vG v'*G(:,:,kk)']; 124 | h_dc_kron = [h_dc_kron h_dc(:,1,kk)']; 125 | end 126 | 127 | y_cc(:,:,kk) = reshape(awgn( (h_dc_kron + vG )*X2 ,snrChannel,'measured'),[M,L]); % cascaded channel data. 128 | % for p = 1:L % for each LIS components. estimate cascaded channel 129 | % v = V(:,p); 130 | % y_cc(:,p,kk) = awgn( (h_dc(:,1,kk)' + v'*G(:,:,kk)' )*X ,snrChannel,'measured'); 131 | % % y_cc_wop(:,p,kk) = awgn( (h_dc(:,1,kk)' + v'*G(:,:,kk)' )*X_wop,snrChannel,'measured'); 132 | % G_e(:,p,kk) = (y_cc(:,p,kk)'*pinv(X) - h_dc_e(:,kk).').'; 133 | % 134 | % % G_e2(:,p,kk) = (y_cc2(:,p,kk)'*pinv(X) - h_dc_e(:,kk).').'; 135 | % % rmse_g = rms ( vec ( G_e(:,p,kk) - G(:,p,kk) ) ) 136 | % end 137 | 138 | %% test. 139 | 140 | %% 141 | % H*V*h_lis(:,1,kk) - G(:,:,kk)*diag(V) 142 | 143 | R_dc(:,:,nr,kk) = reshape(y_dc(kk,:),[sqrt(M) sqrt(M)]); % (direct channel) data to feed ChannelNet_k 144 | R_cc(:,:,nr,kk) = y_cc(:,:,kk); % (cascaded channel) data to feed ChannelNet_k 145 | % R_cc2(:,:,nr,kk) = y_cc2(:,:,kk); % (cascaded channel) data to feed ChannelNet_k 146 | 147 | % R_dc_wop(:,:,nr,kk) = reshape(y_dc_wop(kk,:),[sqrt(M) sqrt(M)]); % (direct channel) data to feed ChannelNet_k 148 | % R_cc_wop(:,:,nr,kk) = y_cc_wop(:,:,kk); % (cascaded channel) data to feed ChannelNet_k 149 | 150 | % R_dc_wop(:,:,nr,k) = reshape(y_dc_wop(k,:),[sqrt(M2) sqrt(M2)]); % (direct channel) data to feed ChannelNet_k 151 | % R_cc_wop(:,:,nr,k) = y_cc_wop(:,:,k); % (cascaded channel) data to feed ChannelNet_k 152 | end 153 | % toc(timeGenerate) 154 | end 155 | %% Channel Estimation. Training data for A3 156 | % jj = 1; 157 | for kk = 1:K % input-output pair of the DL model. 158 | for nr = 1:Nreal 159 | CENet{1,1}.X_dc(:,:,1,jjCE) = real(R_dc(:,:,nr,kk)); % input. 160 | CENet{1,1}.X_dc(:,:,2,jjCE) = imag(R_dc(:,:,nr,kk)); % input. 161 | CENet{1,1}.X_cc(:,:,1,jjCE) = real(R_cc(:,:,nr,kk)); % input. 162 | CENet{1,1}.X_cc(:,:,2,jjCE) = imag(R_cc(:,:,nr,kk)); % input. 163 | % CENet{1,1}.X_cc2(:,:,1,jjCE) = real(R_cc2(:,:,nr,kk)); % input. 164 | % CENet{1,1}.X_cc2(:,:,2,jjCE) = imag(R_cc2(:,:,nr,kk)); % input. 165 | 166 | % ENet{1,1}.X_dc_wop(:,:,1,jjCE) = real(R_dc_wop(:,:,nr,kk)); % input. 167 | % CENet{1,1}.X_dc_wop(:,:,2,jjCE) = imag(R_dc_wop(:,:,nr,kk)); % input. 168 | % CENet{1,1}.X_cc_wop(:,:,1,jjCE) = real(R_cc_wop(:,:,nr,kk)); % input. 169 | % CENet{1,1}.X_cc_wop(:,:,2,jjCE) = imag(R_cc_wop(:,:,nr,kk)); % input. 170 | channel_dc = h_dc(:,1,kk); % output. dc 171 | channel_cc = G(:,:,kk);% output. cc 172 | CENet{1,1}.Y_dc(jjCE,:) = [real(channel_dc(:)); imag(channel_dc(:))]; % output. 173 | CENet{1,1}.Y_cc(jjCE,:) = [real(channel_cc(:)); imag(channel_cc(:))]; % output. 174 | 175 | Z(1,jjCE).h_dc = h_dc; 176 | Z(1,jjCE).G = G; 177 | jjCE = jjCE + 1; 178 | 179 | keepIndex(jjCE) = [nch]; 180 | end 181 | end 182 | %% 183 | nch 184 | end % nch 185 | % sizeOfInput = size(X_HB) 186 | timeGenerate = toc(timeGenerate); 187 | % stopp 188 | %% SFCNN 189 | % fprintf(2,['Train SFCNN \n']) 190 | % [netSFCNN] = train_SFCNN(X_A2,Y_A2); 191 | %% 192 | % fprintf(2,['Train MC-CENet A2 for Channel Estimation \n']) 193 | % [CEnet_A2] = train_CENet_A2(X_A2,Y_A2); 194 | %% ChannelNet 195 | for kkt = 1 196 | fprintf(2,['Train MLP \n']) 197 | % [MLP{1,kkt}.net_dc] = train_MLP(CENet{1,kkt}.X_dc,CENet{1,kkt}.Y_dc,0.00021); 198 | % [MLP{1,kkt}.net_cc] = train_MLP(CENet{1,kkt}.X_cc,CENet{1,kkt}.Y_cc,0.00000211); %0000011 199 | 200 | fprintf(2,['Train SFCNN \n']) 201 | % [SFCNN{1,kkt}.net_dc] = train_SFCNN(CENet{1,kkt}.X_dc,CENet{1,kkt}.Y_dc,0.00021); 202 | % [SFCNN{1,kkt}.net_cc] = train_SFCNN(CENet{1,kkt}.X_cc,CENet{1,kkt}.Y_cc,0.000001511); % 0000011 203 | % 204 | 205 | 206 | % fprintf(2,['Train ChannelNet_DC_WOP{' num2str(k) '} \n']) 207 | % [CEnet{1,k}.net_dc] = train_ChannelNet(CENet{1,k}.X_dc_wop,CENet{1,k}.Y_dc,0.00021); 208 | % fprintf(2,['Train ChannelNet_CC_WOP{' num2str(k) '} \n']) 209 | % [CEnet{1,k}.net_cc] = train_ChannelNet(CENet{1,k}.X_cc_wop,CENet{1,k}.Y_cc,0.000011); 210 | 211 | fprintf(2,['Train ChannelNet_DC{' num2str(kkt) '} \n']) 212 | [CEnet{1,kkt}.net_dc] = train_ChannelNet(CENet{1,kkt}.X_dc,CENet{1,kkt}.Y_dc,0.00021); 213 | fprintf(2,['Train ChannelNet_CC{' num2str(kkt) '} \n']) 214 | [CEnet{1,kkt}.net_cc] = train_ChannelNet(CENet{1,kkt}.X_cc,CENet{1,kkt}.Y_cc,0.00000211); % 0000011 215 | % fprintf(2,['Train ChannelNet_CC_WP2{' num2str(kkt) '} \n']) 216 | % [CEnet{1,kkt}.net_cc2] = train_ChannelNet(CENet{1,kkt}.X_cc2,CENet{1,kkt}.Y_cc,0.0000011); 217 | 218 | 219 | end 220 | %% 221 | % fprintf(2,['Train MLP \n']) 222 | % [MLPNet] = train_MLP(X_HB,Y_HB); 223 | %% Run performance test 224 | % XTest_dc(:,:,1) = real(RTest_dc_wp(:,:,k)); % generate first the test data RTest_dc_wp similar to R_dc and R_cc 225 | % XTest_dc(:,:,2) = imag(RTest_dc_wp(:,:,k)); 226 | % [YPred] = double(predict(CEnet{1,1}.net_dc,XTest_dc)); 227 | % % timeCNN0(iTrial) = toc(timeSFCNNTemp); 228 | % h_e_woP(:,k) = reshape(YPred(1:M) + 1i*YPred(M + 1:2*M), M,1); 229 | % estError_dc_wP = rms(h_e_woP(:,k) - h(:,k)); 230 | -------------------------------------------------------------------------------- /non_overlapbeam.m: -------------------------------------------------------------------------------- 1 | function index = non_overlapbeam(N,L,K) 2 | x = randperm(N); 3 | y = x(1:L*K); 4 | index = reshape(y,L,K); -------------------------------------------------------------------------------- /stopIfAccuracyNotImproving.m: -------------------------------------------------------------------------------- 1 | function stop = stopIfAccuracyNotImproving(info,N) 2 | 3 | stop = false; 4 | 5 | % Keep track of the best validation accuracy and the number of validations for which 6 | % there has not been an improvement of the accuracy. 7 | persistent bestValAccuracy 8 | persistent valLag 9 | 10 | % Clear the variables when training starts. 11 | if info.State == "start" 12 | bestValAccuracy = 0; 13 | valLag = 0; 14 | 15 | elseif ~isempty(info.ValidationLoss) 16 | 17 | % Compare the current validation accuracy to the best accuracy so far, 18 | % and either set the best accuracy to the current accuracy, or increase 19 | % the number of validations for which there has not been an improvement. 20 | if info.ValidationAccuracy > bestValAccuracy 21 | valLag = 0; 22 | bestValAccuracy = info.ValidationAccuracy; 23 | else 24 | valLag = valLag + 1; 25 | end 26 | 27 | % If the validation lag is at least N, that is, the validation accuracy 28 | % has not improved for at least N validations, then return true and 29 | % stop training. 30 | if valLag >= N 31 | stop = true; 32 | end 33 | 34 | end 35 | 36 | end -------------------------------------------------------------------------------- /train_ChannelNet.m: -------------------------------------------------------------------------------- 1 | function [convnetChannelEstimation] = train_ChannelNet(X,Y,l_rate) 2 | %% Train network 3 | dataFRFChainSelection = X; 4 | labelsRFChainSelection = Y; 5 | sizeInputFRFChainSelection = size(dataFRFChainSelection); 6 | sizeOutputFRFChainSelection = size(labelsRFChainSelection); 7 | % val. for regression. 8 | idx = randperm(size(dataFRFChainSelection,4),floor(.2*sizeInputFRFChainSelection(end))); 9 | valDataRFChainSelection = dataFRFChainSelection(:,:,:,idx); 10 | valLabelsFRFChainSelection = labelsRFChainSelection(idx,:); 11 | dataFRFChainSelection(:,:,:,idx) = []; 12 | labelsRFChainSelection(idx,:) = []; 13 | % settings. 14 | miniBatchSize = 16; 15 | numValidationsPerEpoch = 5000; 16 | validationFrequency = 50*1; 17 | %% DNN for HB. 18 | layersFRFChainSelection = [imageInputLayer([sizeInputFRFChainSelection(1:3)],'Normalization', 'zerocenter'); 19 | convolution2dLayer(3,2^8,'Padding','same'); 20 | % batchNormalizationLayer 21 | % reluLayer(); 22 | % maxPooling2dLayer([2 2],'Stride',2); 23 | convolution2dLayer(3,2^8,'Padding','same'); 24 | % batchNormalizationLayer 25 | % reluLayer(); 26 | % maxPooling2dLayer([2 2],'Stride',2); 27 | % convolution2dLayer(2^2,2^7); 28 | % batchNormalizationLayer 29 | % reluLayer(); 30 | % maxPooling2dLayer([2 2],'Stride',2); 31 | fullyConnectedLayer(2^10); 32 | % fullyConnectedLayer(2^14); 33 | % fullyConnectedLayer(2^10); 34 | % maxPooling2dLayer([2 2],'Stride',2); 35 | 36 | % reluLayer(); 37 | % dropoutLayer(); 38 | % fullyConnectedLayer(2^7); 39 | % dropoutLayer(); 40 | % fullyConnectedLayer(2^10); 41 | fullyConnectedLayer(2^10); 42 | % reluLayer(); 43 | % dropoutLayer(); 44 | % fullyConnectedLayer(QFRF); 45 | % softmaxLayer(); 46 | % classificationLayer(); 47 | fullyConnectedLayer(sizeOutputFRFChainSelection(2),'Name','fc_2') 48 | regressionLayer('Name','reg_out') 49 | ]; 50 | optsFRFSelection = trainingOptions('sgdm',... 51 | 'Momentum', 0.9,... 52 | 'InitialLearnRate',l_rate,... % The default value is 0.01. 53 | 'MaxEpochs',5000,... 54 | 'MiniBatchSize',miniBatchSize,... % The default is 128. 55 | 'LearnRateSchedule','piecewise',... 56 | 'LearnRateDropFactor',.5,... 57 | 'LearnRateDropPeriod',10,... 58 | 'L2Regularization',0.000000001,... % The default is 0.0001. 59 | 'ExecutionEnvironment', 'auto',... 60 | 'ValidationData',{valDataRFChainSelection,valLabelsFRFChainSelection},... 61 | 'ValidationFrequency',validationFrequency,... 62 | 'ValidationPatience', 20000,... 63 | 'Plots','none',... 64 | 'Shuffle','every-epoch',... 65 | 'OutputFcn',@(info)stopIfAccuracyNotImproving(info,3)); 66 | %% 67 | % fprintf(2,['Train CENet for Channel Estimation \n']) 68 | timeCENET = tic; 69 | convnetChannelEstimation = trainNetwork(dataFRFChainSelection, labelsRFChainSelection, layersFRFChainSelection, optsFRFSelection); 70 | timeCENET = toc(timeCENET); -------------------------------------------------------------------------------- /wideband_channel_extractDOAs.m: -------------------------------------------------------------------------------- 1 | % wideband_channel_extractDOAs.m 2 | % Today 3 | % 10:13 AM 4 | % 5 | % You edited an item 6 | % Objective C 7 | % wideband_channel_extractDOAs.m 8 | % Last week 9 | % Nov 11 10 | % 11 | % You uploaded an item 12 | % Objective C 13 | % wideband_channel_extractDOAs.m 14 | function [H, At, Ar, DOA, AOA, BETA, delay] = wideband_channel_extractDOAs(Nt,Nr,L,fs,fc,M,Num_users) 15 | % clear all; 16 | % Nt=64; %trasmit antennas 17 | % Nr=1; % receive antennas 18 | % L=3; %paths 19 | % fc=60*10^9; %carrier frequency 20 | % fs=3.5*10^9; % sampling frequency fs=2M(BW) 21 | % BW= 35*10^6; 22 | % M=3; 23 | % K=1; 24 | % Nt_rf=4; 25 | 26 | %%% path delay 27 | % delay_max = 20e-9; 28 | % delay = delay_max*rand(1,L); 29 | delay = [[1.78032951094980e-08,9.55821708146159e-09,7.35131305345536e-09,4.73002944592621e-09,3.13224555779004e-09,8.52959370256540e-09,3.91263028442759e-10,1.18337584383972e-08,8.14978983666684e-09,7.66654915622931e-10]]; 30 | 31 | lambda_c = 3e8/fc; % wavelength 32 | dt = lambda_c/2; 33 | dr = dt; 34 | H = zeros(Nr,Nt,Num_users,M); 35 | % C = zeros(Nt,Nt,Num_users,M); 36 | % Ch = zeros(Nt,Nt,Num_users,M); 37 | 38 | for u=1:1:Num_users 39 | beta(1:L) = exp(1i*2*pi*rand(1,L)); 40 | % beta(1:L) = sqrt(1/2)*(randn(1,L)+1i*randn(1,L)); % of var 1. 41 | % beta(1:L) = ones(1,L); 42 | 43 | %%% DoA 44 | DoA_index = non_overlapbeam(Nt,L,1); 45 | set_t = (-(Nt-1)/2:1:(Nt-1)/2)/(Nt/2); 46 | DoA = ((2/Nt)*rand(1,L) - 1/Nt) + set_t(DoA_index); 47 | %% AoA 48 | % AoA_index = non_overlapbeam(Nr,L,1); 49 | % set_r = (-(Nr-1)/2:1:(Nr-1)/2)/(Nr/2); 50 | % AoA = ((2/Nr)*rand(1,L) - 1/Nr) + set_r(AoA_index); 51 | AoA = 2*rand(1,L) - 1; 52 | 53 | 54 | for m = 1 : M 55 | % f = fc; 56 | f(m) = fc + fs/M*(m-1-(M-1)/2); 57 | lambda(m) = 3e8/f(m); 58 | for l = 1 : L 59 | At(:,l,u) = array_respones(DoA(l),Nt,dt,lambda(1)); 60 | Ar(:,l,u) = array_respones(AoA(l),Nr,dr,lambda(1)); 61 | % H(:,:,u,m) = H(:,:,u,m) + sqrt(Nt*Nr)* Ar(:,l,u)* At(:,l,u)'; 62 | H(:,:,u,m) = H(:,:,u,m) + beta(l)*exp(-1i*2*pi*f(m)*delay(l))* Ar(:,l,u)* At(:,l,u)'; 63 | % C(:,:,u,m) = C(:,:,u,m) + (Nt*Nr)*At(:,l,u)* At(:,l,u)'; 64 | % norm(C(:,:,u,m) - H(:,:,u,m)'*H(:,:,u,m)) 65 | % Ch(:,:,u,m) = Ch(:,:,u,m) + H(:,:,u,m)'*H(:,:,u,m); 66 | end 67 | H(:,:,u,m) = sqrt(Nt*Nr)*H(:,:,u,m); 68 | % H(:,:,u,m) = H(:,:,u,m); 69 | % C(:,:,u,m) = (Nt*Nr)*C(:,:,u,m); 70 | 71 | end 72 | 73 | % norm(C(:,:,u,m) - H(:,:,u,m)'*H(:,:,u,m)) 74 | 75 | % norm(C(:,:,u,m)) - norm(H(:,:,u,m)'*H(:,:,u,m)) 76 | 77 | %% collect data 78 | DOA(u,:) = DoA; 79 | AOA(u,:) = AoA; 80 | BETA(u,:) = beta; 81 | end --------------------------------------------------------------------------------