├── my_gui_app.mlapp ├── two_dim_array_lms.asv ├── two_dim_array_lms.m ├── two_dim_array_adagrad.asv ├── two_dim_array_adagrad.m ├── lms_func.asv ├── lms_func.m ├── adagrad.m ├── adagrad.asv ├── README.md ├── ann.m ├── ann.asv ├── deep_func.asv └── deep_func.m /my_gui_app.mlapp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/gozelalmazovna/Adaptive-Beamforming-Using-Machine-Learning-in-Matlab/HEAD/my_gui_app.mlapp -------------------------------------------------------------------------------- /two_dim_array_lms.asv: -------------------------------------------------------------------------------- 1 | function [weighty,weightz,AF] = two_dim_array_lms(My,Nz,dy,dz,lam,theta_desired,theta_interfered) 2 | %Two dimensional array on yz plane 3 | %by Gozel Murrukova 4 | %My,Nz: number of antennas 5 | %dy,dz: distance between antennas 6 | %theta_desired: desired angle 7 | %theta_interfered: interference angle 8 | 9 | weighty=lms_func(My,dy,lam,theta_desired,theta_interfered); 10 | weightz=lms_func(Nz,dz,lam,theta_desired,theta_interfered); 11 | 12 | j=sqrt(-1); 13 | M=361; %Angle resolution 14 | k=2*pi; %wavenumber 15 | theta=linspace(0,pi,M); 16 | phi=linspace(-pi/2,pi/2,M); 17 | [THETA,PHI]=meshgrid(theta,phi); 18 | deltay=0; %Steering angle in phi 19 | deltaz=0; %Steering angle in theta 20 | %Array factor 21 | psiy=(-k*dy*sin(THETA).*sin(PHI))+deltay; 22 | psiz=(-k*dz*cos(THETA))+ deltaz; 23 | AFy=0; 24 | AFz=0; 25 | for m=1:My 26 | AFy= AFy+ weighty(m)'.* exp(j*(m-1)*psiy); 27 | end 28 | for n=1:Nz 29 | AFz=AFz+ weightz(n)'.*exp(j*(n-1)*psiz); 30 | end 31 | AF=AFy.*AFz; 32 | end 33 | 34 | 35 | -------------------------------------------------------------------------------- /two_dim_array_lms.m: -------------------------------------------------------------------------------- 1 | function [weighty,weightz,AF] = two_dim_array_lms(My,Nz,dy,dz,lam,theta_desired,theta_interfered) 2 | %Two dimensional array on yz plane 3 | %by Gozel Murrukova 4 | %My,Nz: number of antennas 5 | %dy,dz: distance between antennas 6 | %theta_desired: desired angle 7 | %theta_interfered: interference angle 8 | 9 | weighty=lms_func(My,dy,lam,theta_desired,theta_interfered); 10 | weightz=lms_func(Nz,dz,lam,theta_desired,theta_interfered); 11 | 12 | j=sqrt(-1); 13 | M=361; %Angle resolution 14 | k=2*pi; %wavenumber 15 | theta=linspace(0,pi,M); 16 | phi=linspace(-pi/2,pi/2,M); 17 | [THETA,PHI]=meshgrid(theta,phi); 18 | deltay=0; %Steering angle in phi 19 | deltaz=0; %Steering angle in theta 20 | %Array factor 21 | psiy=(-k*dy*sin(THETA).*sin(PHI))+deltay; 22 | psiz=(-k*dz*cos(THETA))+ deltaz; 23 | AFy=0; 24 | AFz=0; 25 | for m=1:My 26 | AFy= AFy+ weighty(m)'.* exp(j*(m-1)*psiy); 27 | end 28 | for n=1:Nz 29 | AFz=AFz+ weightz(n)'.*exp(j*(n-1)*psiz); 30 | end 31 | AF=AFy.*AFz; 32 | end 33 | 34 | 35 | -------------------------------------------------------------------------------- /two_dim_array_adagrad.asv: -------------------------------------------------------------------------------- 1 | function [weighty,weightz,AF] = two_dim_array_adagrad(My,Nz,dy,dz,lam,theta_desired,theta_interfered) 2 | %Two dimensional array on yz plane 3 | %by Gozel Murrukova 4 | %My,Nz: number of antennas 5 | %dy,dz: distance between antennas 6 | %theta_desired: desired angle 7 | %theta_interfered: interference angle 8 | 9 | weighty=adagrad(My,dy,lam,theta_desired,theta_interfered); 10 | weightz=adagrad(Nz,dz,lam,theta_desired,theta_interfered); 11 | 12 | j=sqrt(-1); 13 | M=361; %Angle resolution 14 | k=2*pi; %wavenumber 15 | theta=linspace(0,pi,M); 16 | phi=linspace(-pi/2,pi/2,M); 17 | [THETA,PHI]=meshgrid(theta,phi); 18 | deltay=0; %Steering angle in phi 19 | deltaz=0; %Steering angle in theta 20 | %Array factor 21 | psiy=(-k*dy*sin(THETA).*sin(PHI))+deltay; 22 | psiz=(-k*dz*cos(THETA))+ deltaz; 23 | AFy=0; 24 | AFz=0; 25 | for m=1:My 26 | AFy= AFy+ weighty(m)'.* exp(j*(m-1)*psiy); 27 | end 28 | for n=1:Nz 29 | AFz=AFz+ weightz(n)'.*exp(j*(n-1)*psiz); 30 | end 31 | AF=AFy.*AFz; 32 | end 33 | 34 | 35 | -------------------------------------------------------------------------------- /two_dim_array_adagrad.m: -------------------------------------------------------------------------------- 1 | function [weighty,weightz,AF] = two_dim_array_adagrad(My,Nz,dy,dz,lam,theta_desired,theta_interfered) 2 | %Two dimensional array on yz plane 3 | %by Gozel Murrukova 4 | %My,Nz: number of antennas 5 | %dy,dz: distance between antennas 6 | %theta_desired: desired angle 7 | %theta_interfered: interference angle 8 | 9 | weighty=adagrad(My,dy,lam,theta_desired,theta_interfered); 10 | weightz=adagrad(Nz,dz,lam,theta_desired,theta_interfered); 11 | 12 | j=sqrt(-1); 13 | M=361; %Angle resolution 14 | k=2*pi; %wavenumber 15 | theta=linspace(0,pi,M); 16 | phi=linspace(-pi/2,pi/2,M); 17 | [THETA,PHI]=meshgrid(theta,phi); 18 | deltay=0; %Steering angle in phi 19 | deltaz=0; %Steering angle in theta 20 | %Array factor 21 | psiy=(-k*dy*sin(THETA).*sin(PHI))+deltay; 22 | psiz=(-k*dz*cos(THETA))+ deltaz; 23 | AFy=0; 24 | AFz=0; 25 | for m=1:My 26 | AFy= AFy+ weighty(m)'.* exp(j*(m-1)*psiy); 27 | end 28 | for n=1:Nz 29 | AFz=AFz+ weightz(n)'.*exp(j*(n-1)*psiz); 30 | end 31 | AF=AFy.*AFz; 32 | end 33 | 34 | 35 | -------------------------------------------------------------------------------- /lms_func.asv: -------------------------------------------------------------------------------- 1 | function [w] = lms_func(N,d,lam,thetaS,thetaI) 2 | %Calculate weights using LMS algorithm which then are plotted in GUI 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | j = sqrt(-1); 11 | T=1E-3; 12 | t=(1:100)*T/100; 13 | it=1:100; 14 | S=cos(2*pi*t/T); 15 | thetaS = thetaS*pi/180; 16 | I = randn(1,100); 17 | thetaI = thetaI*pi/180; 18 | i=1:N; 19 | vS=exp(1j*(i-1)*2*pi*d*sin(thetaS)).'; 20 | vI=exp(1j*(i-1)*2*pi*d*sin(thetaI)).'; 21 | 22 | w = zeros(N,1); 23 | X=(vS+vI); 24 | Rx=X*X'; 25 | mu=1/(4*real(trace(Rx))); 26 | wi=zeros(N,max(it)); 27 | for n = 1:length(S) 28 | x = S(n)*vS + I(n)*vI; 29 | y=w'*x; 30 | e = conj(S(n)) - y; 31 | w=w+mu*conj(e)*x; 32 | wi(:,n)=w; 33 | end 34 | 35 | w = (w./w(1)); 36 | 37 | end 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /lms_func.m: -------------------------------------------------------------------------------- 1 | function [w] = lms_func(N,d,lam,thetaS,thetaI) 2 | %Calculate weights using LMS algorithm which then are plotted in GUI 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | j = sqrt(-1); 11 | T=1E-3; 12 | t=(1:100)*T/100; 13 | it=1:100; 14 | S=cos(2*pi*t/T); 15 | thetaS = thetaS*pi/180; 16 | I = randn(1,100); 17 | thetaI = thetaI*pi/180; 18 | i=1:N; 19 | vS=exp(1j*(i-1)*2*pi*d*sin(thetaS)).'; 20 | vI=exp(1j*(i-1)*2*pi*d*sin(thetaI)).'; 21 | 22 | w = zeros(N,1); 23 | X=(vS+vI); 24 | Rx=X*X'; 25 | mu=1/(4*real(trace(Rx))); 26 | wi=zeros(N,max(it)); 27 | for n = 1:length(S) 28 | x = S(n)*vS + I(n)*vI; 29 | y=w'*x; 30 | e = conj(S(n)) - y; 31 | w=w+mu*conj(e)*x; 32 | wi(:,n)=w; 33 | end 34 | 35 | w = (w./w(1)); 36 | 37 | end 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /adagrad.m: -------------------------------------------------------------------------------- 1 | function [w] = adagrad(N,d,lam,thetaS,thetaI) 2 | %Adagrad is gradient stochastic method for calculation of weights 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | 11 | T=1E-3; 12 | t=(1:100)*T/100; 13 | it=1:100; 14 | S=cos(2*pi*t/T); 15 | thetaS = thetaS*pi/180; 16 | I = randn(1,100); 17 | thetaI = thetaI*pi/180; 18 | i=1:N; 19 | vS=exp(1j*(i-1)*2*pi*d*sin(thetaS)).'; 20 | vI=exp(1j*(i-1)*2*pi*d*sin(thetaI)).'; 21 | w = zeros(N,1); 22 | mu = 0.01; %Fixed step size 23 | wi=zeros(N,max(it)); 24 | gx_v = 0; 25 | 26 | for n = 1:length(S) 27 | x = S(n)*vS + I(n)*vI; 28 | y=w'*x; 29 | e = conj(S(n)) - y; 30 | gx_v = 0.9*gx_v + 0.1*(conj(e)*x).^2; 31 | w=w+ mu*inv(sqrt(diag(gx_v)))*conj(e)*x; 32 | wi(:,n)=w; 33 | end 34 | 35 | w = (w./w(1)); % normalize results to first weight 36 | end 37 | 38 | -------------------------------------------------------------------------------- /adagrad.asv: -------------------------------------------------------------------------------- 1 | function [w] = adagrad(N,d,lam,thetaS,thetaI) 2 | %Adagrad is gradient stochastic method for calculation of weights 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | 11 | T=1E-3; 12 | t=(1:100)*T/100; 13 | it=1:100; 14 | S=cos(2*pi*t/T); 15 | thetaS = thetaS*pi/180; 16 | I = randn(1,100); 17 | thetaI = thetaI*pi/180; 18 | i=1:N; 19 | vS=exp(1j*(i-1)*2*pi*d*sin(thetaS)).'; 20 | vI=exp(1j*(i-1)*2*pi*d*sin(thetaI)).'; 21 | w = zeros(N,1); 22 | mu = 0.01; %Fixed step size 23 | wi=zeros(N,max(it)); 24 | gx_v = 0; 25 | 26 | for n = 1:length(S) 27 | x = S(n)*vS + I(n)*vI; 28 | y=w'*x; 29 | e = conj(S(n)) - y; 30 | gx_v = 0.9*gx_v + 0.1*(conj(e)*x).^2; 31 | w=w+ mu*inv(sqrt(diag(gx_v)))*conj(e)*x; 32 | wi(:,n)=w; 33 | end 34 | 35 | w = (w./w(1)); % normalize results to first weight 36 | end 37 | 38 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Adaptive-Beamforming-Using-Machine-Learning-in-Matlab-(Simulation-video-link-is-down-below) 2 | Adaptive Beamforming techniques can be enhanced by using Machine Learning Algorithms. 3 | 4 | As a basis Least Means Squares algorithm (adaptive) was used to calculate weigths and to develop the dataset. 5 | 6 | Three different machine learning agorithms were used, so that users can compare different designs and choose suitable results: 7 | 8 | 1.Adaptive Gradient algorithm was used to improve LMS and enable the model to learn and adjust the learning rate. 9 | 10 | 2.Deep Learning algorithm with LSTM and Regression layers were used to predict weights and plot Array factors for different inputs. 11 | 12 | 3.Artificial Neural Networks algorithm was used with the same dataset as deep learning model. 13 | 14 | All of the models were built upon easy to use Graphical User Interface where different predictions and algorithms can be compared and visualized. 15 | 16 | Note: Results can be improved with different datasets which are left for future development. 17 | 18 | Simulation video link: https://youtu.be/zaapLjpq6TE 19 | 20 | -------------------------------------------------------------------------------- /ann.m: -------------------------------------------------------------------------------- 1 | function [w] = ann(N,d,lam,thetaS,thetaI) 2 | %Artificial neural network algorithm to calculate weights 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | data = readmatrix("my_data.csv"); 11 | x = data(1:3700,1:5); 12 | y = data(1:3700,6:25); 13 | 14 | 15 | y(isnan(y)) = 0; 16 | y2 = (y - min(y)) ./ ( max(y) - min(y)); 17 | x(isnan(x)) = 0; 18 | X_norm = (x - repmat(mean(x),size(x, 1), 1))./repmat(std(x),size(x, 1), 1); 19 | 20 | xt = (X_norm)'; 21 | yt = abs(y2'); 22 | 23 | for j = 1:2 24 | hiddenLayerSize = [7 7]; 25 | net = fitnet(hiddenLayerSize); 26 | net.divideParam.trainRatio = 70/100; 27 | net.divideParam.valRatio = 30/100; 28 | net.divideParam.testRatio = 0/100; 29 | [net,tr] = train(net,xt,yt); 30 | end 31 | a = [N,d,lam,thetaS,thetaI]; 32 | b = a - repmat(mean(a),size(a, 1), 1)./repmat(std(a),size(a, 1), 1); 33 | ypred = (net((b)')); 34 | w = ypred(1:a(1),:)'; 35 | 36 | end 37 | -------------------------------------------------------------------------------- /ann.asv: -------------------------------------------------------------------------------- 1 | function [w] = ann(N,d,lam,thetaS,thetaI) 2 | %Artificial neural network algorithm to calculate weights 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | data = readmatrix("my_data.csv"); 11 | x = data(1:3700,1:5); 12 | y = data(1:3700,6:25); 13 | 14 | 15 | y(isnan(y)) = 0; 16 | y2 = (y - min(y)) ./ ( max(y) - min(y)); 17 | x(isnan(x)) = 0; 18 | X_norm = (x - repmat(mean(x),size(x, 1), 1))./repmat(std(x),size(x, 1), 1); 19 | 20 | xt = (X_norm)'; 21 | yt = abs(y2'); 22 | 23 | for j = 1:2 24 | hiddenLayerSize = [7 7]; 25 | net = fitnet(hiddenLayerSize); 26 | net.divideParam.trainRatio = 70/100; 27 | net.divideParam.valRatio = 30/100; 28 | net.divideParam.testRatio = 0/100; 29 | [net,tr] = train(net,xt,yt); 30 | end 31 | a = [N,d,lam,thetaS,thetaI]; 32 | b = a - repmat(mean(a),size(a, 1), 1)./repmat(std(a),size(a, 1), 1); 33 | ypred = (net((b)')); 34 | w = ypred(1:a(1),:)'; 35 | 36 | end 37 | -------------------------------------------------------------------------------- /deep_func.asv: -------------------------------------------------------------------------------- 1 | function [w] = deep_func(N,d,lam,thetaS,thetaI) 2 | %Calculates weights using depp learning algorithm 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | data = readmatrix("my_data.csv"); 11 | x = data(1:3700,1:5); 12 | y = data(1:3700,6:end); 13 | 14 | y(isnan(y)) = 0; 15 | Y_norm = (y - min(y)) ./ ( max(y) - min(y)); 16 | x(isnan(x)) = 0; 17 | X_norm = (x - repmat(mean(x),size(x, 1), 1))./repmat(std(x),size(x, 1), 1); 18 | 19 | Xtrain = (X_norm(1:3000,:))'; 20 | Ytrain = abs(Y_norm(1:3000,:))'; 21 | 22 | Xvalidation = (X_norm(3001:3700,:))'; 23 | Yvalidation = abs(Y_norm(3001:3700,:))'; 24 | 25 | inputSize = 5; 26 | numResponses = 20; 27 | 28 | numHiddenUnits = 100; 29 | layers = [ sequenceInputLayer(inputSize) 30 | batchNormalizationLayer 31 | lstmLayer(numHiddenUnits) 32 | batchNormalizationLayer 33 | fullyConnectedLayer(numResponses) 34 | regressionLayer]; 35 | 36 | opts = trainingOptions('adam',... 37 | 'MaxEpochs',40, ... 38 | 'LearnRateSchedule','piecewise', ... 39 | 'LearnRateDropPeriod',30, ... 40 | 'LearnRateDropFactor',0.2, ... 41 | 'GradientThreshold',0.01, ... 42 | 'InitialLearnRate',0.01, ... 43 | 'ValidationData',{Xvalidation,Yvalidation}, ... 44 | 'Plots','training-progress'); 45 | 46 | net = trainNetwork(Xtrain,Ytrain,layers,opts); 47 | 48 | a = [N,d,lam,thetaS,thetaI]; 49 | b = a - repmat(mean(a),size(a, 1), 1)./repmat(std(a),size(a, 1), 1); 50 | ypred =(predict(net,(b)')); 51 | w = ypred(1:a(1),:)'; 52 | 53 | end 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | -------------------------------------------------------------------------------- /deep_func.m: -------------------------------------------------------------------------------- 1 | function [w] = deep_func(N,d,lam,thetaS,thetaI) 2 | %Calculates weights using depp learning algorithm 3 | %by Gozel Murrukova 4 | % Inputs: N - number of antennas, 5 | % d - distance between antennas, 6 | % lambda - lambda value, 7 | % theta_desired - desired angle, 8 | % theta_interference - interference angle 9 | % Outputs: weights for calculation of AF 10 | data = readmatrix("my_data.csv"); 11 | x = data(1:3700,1:5); 12 | y = data(1:3700,6:end); 13 | 14 | y(isnan(y)) = 0; 15 | Y_norm = (y - min(y)) ./ ( max(y) - min(y)); 16 | x(isnan(x)) = 0; 17 | X_norm = (x - repmat(mean(x),size(x, 1), 1))./repmat(std(x),size(x, 1), 1); 18 | 19 | Xtrain = (X_norm(1:3000,:))'; 20 | Ytrain = abs(Y_norm(1:3000,:))'; 21 | 22 | Xvalidation = (X_norm(3001:3700,:))'; 23 | Yvalidation = abs(Y_norm(3001:3700,:))'; 24 | 25 | inputSize = 5; 26 | numResponses = 20; 27 | 28 | numHiddenUnits = 100; 29 | layers = [ sequenceInputLayer(inputSize) 30 | batchNormalizationLayer 31 | lstmLayer(numHiddenUnits) 32 | batchNormalizationLayer 33 | fullyConnectedLayer(numResponses) 34 | regressionLayer]; 35 | 36 | opts = trainingOptions('adam',... 37 | 'MaxEpochs',40, ... 38 | 'LearnRateSchedule','piecewise', ... 39 | 'LearnRateDropPeriod',30, ... 40 | 'LearnRateDropFactor',0.2, ... 41 | 'GradientThreshold',0.01, ... 42 | 'InitialLearnRate',0.01, ... 43 | 'ValidationData',{Xvalidation,Yvalidation}, ... 44 | 'Plots','training-progress'); 45 | 46 | net = trainNetwork(Xtrain,Ytrain,layers,opts); 47 | 48 | a = [N,d,lam,thetaS,thetaI]; 49 | b = a - repmat(mean(a),size(a, 1), 1)./repmat(std(a),size(a, 1), 1); 50 | ypred =(predict(net,(b)')); 51 | w = ypred(1:a(1),:)'; 52 | 53 | end 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | --------------------------------------------------------------------------------