///////////////////
upperBound =  10;
lowerBound = 3;
numberOfExperiments = 5;
x=1:upperBound;
y1=zeros(1,upperBound);
y2=zeros(1,upperBound);
for i=lowerBound:upperBound
for j=1:i*numberOfExperiments
problem = Problem(i, i);
[cost , numberOfExpandedNodes] = SolveMaze(problem, false, BFSFringe);
y1(i) = y1(i) + numberOfExpandedNodes;
[cost , numberOfExpandedNodes] = SolveMazeBidirectional(problem, false, BFSFringe, BFSFringe);
y2(i) = y2(i) + numberOfExpandedNodes;
end
y1(i) = y1(i)/(i*numberOfExperiments);
y2(i) = y2(i)/(i*numberOfExperiments);
end
figure(‘name’,’Normal vs Bidirectional BFS’);
hold on
axis([lowerBound upperBound 0 max(max(y1),max(y2))]);
plot(x,y1,’r’);
plot(x,y2,’b’);
clear;

EvaluateDFS.m
upperBound = 10;
lowerBound = 3;
numberOfExperiments = 10;
x=1:upperBound;
y=zeros(1,upperBound);
for i=lowerBound:upperBound
for j=1:i*numberOfExperiments 
problem = Problem(i, i);
[cost , numberOfExpandedNodes] = SolveMaz(problem, false, DFSFringe, SLHeuristic);
y(i) = y(i) + numberOfExpandedNodes;
end

y(i) = y(i)/(i*numberOfExperiments;
end
figure(‘name’,’DFS Evaluation’)
hold on
axis([lowerBound upperBound 0 max(y)]);
plot(x,y,’r’);
clear;

EvaluateBestFirst.m
upperBound = 10;
lowerBound = 3;
numberOfExperiments = 10;
x=1:upperBound;
y=zeros(1,upperBound 
for i=lowerBound:upperBound
for j=1:i*numberOfExperiments
problem = Problem(i, i);
[cost , numberOfExpandedNodes] = SolveMaze(problem, false, BestFirstFringe, SLHeuristic);
y(i) = y(i) + numberOfExpandedNodes;
end
y(i) = y(i)/(i*numberOfExperiments);
end
figure(‘name’,’Best First Evaluation’);
hold on
axis([lowerBound upperBound 0 max(y)]);
plot(x,y,’g’);
clear;

EvaluateAStar.m
upperBound = 10;
lowerBound = 3;
numberOfExperiments = 10;
x=1:upperBound;
y=zeros(1,upperBound);
for i=lowerBound:upperBound
for j=1:i*numberOfExperiments
problem = Problem(i, i);
[cost , numberOfExpandedNodes] = SolveMaze(problem, false, AStarFringe, SLHeuristic);
y(i) = y(i) + numberOfExpandedNodes;
end
y(i) = y(i)/(i*numberOfExperiments);
end
figure(‘name’,’A* Evaluation’);
hold on
axis([lowerBound upperBound 0 max(y)]);
plot(x,y,’b’);
clear;

ExampleNormalVsBidirectional.m
function ExampleNormalVsBidirectional(numberOfRows, numberOfColumns)
problem = Problem(numberOfRows, numberOfColumns);
close all;
[cost , numberOfExpandedNodes] = SolveMaze(problem, true, BFSFringe);
disp(‘Solution cost with normal BFS:’);
disp(cost);
disp(‘Number of expanded nodes with normal BFS’);
disp(numberOfExpandedNodes);
[cost , numberOfExpandedNodes] = SolveMazeBidirectional(problem, true, BFSFringe,BFSFringe);
disp(‘Solution cost with bidirectional BFS:’);
disp(cost);
disp(‘Number of expanded nodes with bidirectional BFS:’);
disp(numberOfExpandedNodes);
end

ExampleDFS.m
function ExampleDFS(numberOfRows, numberOfColumns)
disp(‘Depth First Search’);
problem = Problem(numberOfRows, numberOfColumns);
close all;
[cost , numberOfExpandedNodes] = SolveMaze(problem, true, DFSFringe);
disp(‘Solution cost:’);
disp(cost);
disp(‘Number of expanded nodes:’);
disp(numberOfExpandedNodes);
end

ExampleBFS.m
function ExampleBFS(numberOfRows, numberOfColumns)
disp(‘Breadth First Search’);
problem = Problem(numberOfRows, numberOfColumns);
close all;
[cost , numberOfExpandedNodes] = SolveMaze(problem, true, BFSFringe);
disp(‘Solution cost:’);
disp(cost);
disp(‘Number of expanded nodes:’);
disp(numberOfExpandedNodes);
end

ExampleBestFirst.m
function ExampleBestFirst(numberOfRows, numberOfColumns)
disp(‘Best First Search, Straight Line Distance Heuristic’);
problem = Problem(numberOfRows, numberOfColumns);
close all;
[cost , numberOfExpandedNodes] = SolveMaze(problem, true, BestFirstFringe, SLHeuristic);
disp(‘Solution cost:’);
disp(cost);
disp(‘Number of expanded nodes:’);
disp(numberOfExpandedNodes);
end

ExampleAStar.m
function ExampleAStar(numberOfRows, numberOfColumns)
disp(‘A* Search, Straight Line Distance Heuristic’);
problem = Problem(numberOfRows, numberOfColumns);
close all;
[cost , numberOfExpandedNodes] = SolveMaze(problem, true, AStarFringe, SLHeuristic);
disp(‘Solution cost:’);
disp(cost);
disp(‘Number of expanded nodes:’);
disp(numberOfExpandedNodes);
end

for i=1:numberOfColumns
x=zeros(0);
y=zeros(0);
for j=1:numberOfRows
if(arrayVersion(j,i) == 1)
x = [x i];
y = [y j];
else
plot(x,y,’-ks’,’LineWidth’,3,…
‘MarkerEdgeColor’,’k’,…
‘MarkerFaceColor’,’g’,…
‘MarkerSize’,5)
x=zeros(0);
y=zeros(0);
end
end
plot(x,y,’-ks’,’LineWidth’,3,…
‘MarkerEdgeColor’,’k’,…
‘MarkerFaceColor’,’g’,…
‘MarkerSize’,5)
end
if isempty(solution) == false
[x, y] = ConvertToArray(solution);
plot(x,y,’:r’, ‘LineWidth’,2);
else
text(numberOfColumns/2,0,’FAILURE’);
end
text(problem.InitialState.Column, problem.InitialState.Row, ‘S’);
text(problem.GoalState.Column, problem.GoalState.Row, ‘G’);
hold off
end
function [x, y] = ConvertToArray(path)
x=zeros(0);
y=zeros(0);
for node = path
x = [x node.State.Column];
y = [y node.State.Row];
end
end

DrawMaze.m
function DrawMaze(problem, solution)
arrayVersion = problem.ArrayVersion;
[numberOfRows, numberOfColumns] = size(problem.States);
figure;
hold on;
axis ij
axis([0.5 numberOfColumns+0.5 0.5 numberOfRows+0.5]);
for i=1:numberOfRows
x=zeros(0);
y=zeros(0);
for j=1:numberOfColumns
if(arrayVersion(i,j) == 1)
x = [x j];
y = [y i];
else
plot(x,y,’-ks’,’LineWidth’,3,…
‘MarkerEdgeColor’,’k’,…
‘MarkerFaceColor’,’g’,…
‘MarkerSize’,5)
x=zeros(0);
y=zeros(0);
end
end
plot(x,y,’-ks’,’LineWidth’,3,…
‘MarkerEdgeColor’,’k’,…
‘MarkerFaceColor’,’g’,…
‘MarkerSize’,5)
end

SolveMazeBidirectional.m
function [cost , numberOfExpandedNodes] = SolveMazeBidirectional(problem, drawMaze, fringe1, fringe2, heuristic1, heuristic2)
if isa(fringe1,’HeuristicFringe’)
fringe1.Set(problem,heuristic1);
end
if isa(fringe2,’HeuristicFringe’)
if nargin == 5
fringe2.Set(problem,heuristic1);
else
fringe2.Set(problem,heuristic2);
end
end
[solution, cost] = BidirectionalSearch(problem, fringe1, fringe2);
numberOfExpandedNodes = fringe1.NumberOfExpandedNodes + fringe2.NumberOfExpandedNodes;
if drawMaze
DrawMaze (problem, solution);
end
end

SolveMaze.m
function [cost , numberOfExpandedNodes] = SolveMaze(problem, drawMaze, fringe, heuristic)
if isa(fringe,’HeuristicFringe’)
fringe.Set(problem,heuristic);
end
[solution, cost] = GraphSearch(problem,fringe);
numberOfExpandedNodes = fringe.NumberOfExpandedNodes;
if drawMaze
DrawMaze(problem, solution);
end
end

Problem.m
classdef Problem < handle
properties
InitialState
GoalState
States = State.empty;
ArrayVersion
end
methods
function problem = Problem(numberOfRows, numberOfColumns)
problem.States(1:numberOfRows, 1: numberOfColumns) = State;
for i = 1:numberOfRows
for j = 1:numberOfColumns
if rand < 0.4
blocked = true;
else
blocked = false;
end
problem.States(i,j) = State(i,j,blocked);
problem.ArrayVersion(i,j) = blocked;
end
end

index = round(rand*(i*j-1))+1;
problem.InitialState = problem.States(index);
problem.InitialState.Blocked = false;
problem.ArrayVersion(index) = 0;
index = round(rand*(i*j-1))+1;
problem.GoalState = problem.States(index);
problem.GoalState.Blocked = false;
problem.ArrayVersion(index) = 0;
end
function result = GoalTest(problem, state)
if state == problem.GoalState
result = true;
else
result = false;
end
end
function [actions, results] = SuccessorFunction(problem, state)
[numberOfRows, numberOfColumns] = size(problem.States);
row = state.Row;
column = state.Column;
actions = double.empty;
results = State.empty;
index = 0;
if(column>1 && problem.States(row,column-1).Blocked == false)
index = index + 1;
actions(index) = 4; % left (according to keyboard’s numeric keypad!)
results(index) = problem.States(row,column-1);
end
if(column<numberOfColumns && problem.States(row,column+1).Blocked == false)
index = index + 1;
actions(index) = 6; % right
results(index) = problem.States(row,column+1);
end
if(row>1 && problem.States(row-1,column).Blocked == false)
index = index + 1;
actions(index) = 8; % up
results(index) = problem.States(row-1,column);
end
if(row<numberOfRows && problem.States(row+1,column).Blocked == false)
index = index + 1;
actions(index) = 2; % down
results(index) = problem.States(row+1,column);
end
if(column>1 && row>1 && problem.States(row-1,column-1).Blocked == false)
index = index + 1;
actions(index) = 7; % upper left
results(index) = problem.States(row-1,column-1);
end

if(column<numberOfColumns && row>1 && problem.States(row-1,column+1).Blocked == false)
index = index + 1;
actions(index) = 9; % upperRight
results(index) = problem.States(row-1,column+1);
end
if(column>1 && row<numberOfRows && problem.States(row+1,column-1).Blocked == false)
index = index + 1;
actions(index) = 1; % bottomLeft
results(index) = problem.States(row+1,column-1);
end
if(column<numberOfColumns && row<numberOfRows && problem.States(row+1,column+1).Blocked == false)
index = index + 1;
actions(index) = 3; % bottomRight
results(index) = problem.States(row+1,column+1);
end
end
end
end

BidirectionalSearch.m
function [solution, cost] = BidirectionalSearch(problem, fringe1, fringe2)
closed = State.empty;
fringe1.Insert(MakeNode(problem.InitialState));
fringe2.Insert(MakeNode(problem.GoalState));
while(true)
if fringe1.IsEmpty || fringe2.IsEmpty
solution = Node.empty; % Failure
cost = 0;
break;
end
[intersectingNodeFromFring1, intersectingNodeFromFring2] = FindIntersection(fringe1,fringe2);
if isempty(intersectingNodeFromFring1) == false
[solution, cost] = Solution(intersectingNodeFromFring1, intersectingNodeFromFring2);
break;
end
node1 = fringe1.RemoveFront();
node2 = fringe2.RemoveFront();
if Contains(closed, node1.State) == false
closed = [node1.State closed];
fringe1.InsertAll(Expand(node1, problem));
end
if Contains(closed, node2.State) == false
closed = [node2.State closed];
fringe2.InsertAll(Expand(node2, problem));
end
end
end
function [intersectingNodeFromFring1, intersectingNodeFromFring2] = FindIntersection(fringe1,fringe2)
intersectingNodeFromFring1 = Node.empty;
intersectingNodeFromFring2 = Node.empty;
for node1 = fringe1.Nodes
for node2 = fringe2.Nodes
if node1 == node2
intersectingNodeFromFring1 = node1;
intersectingNodeFromFring2 = node2;

break;
end
end
end
end
function [solution, cost] = Solution(node1,node2)
solution = node1;
currentNode = node1;
rootReached = false;
while(rootReached == false)
currentNode = currentNode.ParentNode;
solution = [currentNode solution];
if isempty(currentNode) || isempty(currentNode.ParentNode)
rootReached = true;
end
end
currentNode = node2;
rootReached = false;
while(rootReached == false)
currentNode = currentNode.ParentNode;
solution = [solution currentNode];
if isempty(currentNode) || isempty(currentNode.ParentNode)
rootReached = true;
end
end
cost = node1.PathCost + node2.PathCost;
end
5.16. Problem.m
classdef Problem < handle
properties
InitialState
GoalState
States = State.empty;
ArrayVersion
end
methods
function problem = Problem(numberOfRows, numberOfColumns)
problem.States(1:numberOfRows, 1: numberOfColumns) = State;
for i = 1:numberOfRows
for j = 1:numberOfColumns
if rand < 0.4
blocked = true;
else
blocked = false;
end
problem.States(i,j) = State(i,j,blocked);
problem.ArrayVersion(i,j) = blocked;
end
end

index = round(rand*(i*j-1))+1;
problem.InitialState = problem.States(index);
problem.InitialState.Blocked = false;
problem.ArrayVersion(index) = 0;
index = round(rand*(i*j-1))+1;
problem.GoalState = problem.States(index);
problem.GoalState.Blocked = false;
problem.ArrayVersion(index) = 0;
end
function result = GoalTest(problem, state)
if state == problem.GoalState
result = true;
else
result = false;
end
end
function [actions, results] = SuccessorFunction(problem, state)
[numberOfRows, numberOfColumns] = size(problem.States);
row = state.Row;
column = state.Column;
actions = double.empty;
results = State.empty;
index = 0;
if(column>1 && problem.States(row,column-1).Blocked == false)
index = index + 1;
actions(index) = 4; % left (according to keyboard’s numeric keypad!)
results(index) = problem.States(row,column-1);
end
if(column<numberOfColumns && problem.States(row,column+1).Blocked == false)
index = index + 1;
actions(index) = 6; % right
results(index) = problem.States(row,column+1);
end
if(row>1 && problem.States(row-1,column).Blocked == false)
index = index + 1;
actions(index) = 8; % up
results(index) = problem.States(row-1,column);
end
if(row<numberOfRows && problem.States(row+1,column).Blocked == false)
index = index + 1;
actions(index) = 2; % down
results(index) = problem.States(row+1,column);
end
if(column>1 && row>1 && problem.States(row-1,column-1).Blocked == false)
index = index + 1;
actions(index) = 7; % upper left
results(index) = problem.States(row-1,column-1);
end

if(column<numberOfColumns && row>1 && problem.States(row-1,column+1).Blocked == false)
index = index + 1;
actions(index) = 9; % upperRight
results(index) = problem.States(row-1,column+1);
end
if(column>1 && row<numberOfRows && problem.States(row+1,column-1).Blocked == false)
index = index + 1;
actions(index) = 1; % bottomLeft
results(index) = problem.States(row+1,column-1);
end
if(column<numberOfColumns && row<numberOfRows && problem.States(row+1,column+1).Blocked == false)
index = index + 1;
actions(index) = 3; % bottomRight
results(index) = problem.States(row+1,column+1);
end
end
end
end

نوشته کد classical AI search algorithms اولین بار در ايران متلب. پدیدار شد.

• علوم ریاضیاتی: MATLAB یکی از محبوب‌ترین نرم‌افزارهای مورد استفاده در ریاضیات است و از آن به عنوان یک محیط محاسباتی و تحلیلی استفاده می‌شود. MATLAB برای حل مسائل مربوط به نظریه گراف، محاسبات عددی، آمار و احتمالات، رمزنگاری، روش‌های تفاضلی، روش‌های جبری و غیره استفاده می‌شود.
• علوم مهندسی: MATLAB یکی از مورد استفاده قرار گرفته در علوم مهندسی است و برای حل مسائل مختلف مربوط به مهندسی برق، مهندسی مکانیک، مهندسی شیمی، مهندسی عمران و غیره استفاده می‌شود. MATLAB برای تحلیل و طراحی سیستم‌های کنترل، شبیه‌سازی سیستم‌های انرژی، مدلسازی سیستم‌های تشخیص خطا و غیره مورد استفاده قرار می‌گیرد.
• علوم پزشکی: MATLAB یکی از برترین نرم‌افزارهای مورد استفاده در پزشکی است و برای تحلیل داده‌های پزشکی، تحلیل سیگنال‌های پزشکی، تحلیل تصویر پزشکی و غیره استفاده می‌شود. MATLAB به عنوان یک محیط محاسباتی و تحلیلی برای بسیاری از پژوهش‌های پزشکی مورد استفاده قرار می‌گیرد.
• علوم زمین‌شناسی: MATLAB برای تحلیل داده‌های زمین‌شناسی و مهندسی زمین، تحلیل داده‌های رادار و شبیه
• علوم اقتصادی: MATLAB برای تحلیل داده‌های مالی و اقتصادی، مدلسازی سیستم‌های مالی، طراحی و پیاده‌سازی سیستم‌های معاملاتی و غیره استفاده می‌شود.
• علوم فیزیکی: MATLAB برای مدلسازی و شبیه‌سازی سیستم‌های فیزیکی، حل مسائل مربوط به الکترودینامیک، نوری، مغناطیسی، اپتیک و غیره استفاده می‌شود.
• علوم روانشناسی: MATLAB برای تحلیل داده‌های روان‌شناختی، مدلسازی و شبیه‌سازی سیستم‌های روان‌شناختی و طراحی و پیاده‌سازی آزمایش‌های روان‌شناختی و غیره استفاده می‌شود.
• علوم بیولوژی: MATLAB برای تحلیل داده‌های بیولوژیکی، مدلسازی سیستم‌های بیولوژیکی، طراحی و پیاده‌سازی آزمایش‌های بیولوژیکی و غیره استفاده می‌شود.
• علوم کامپیوتر: MATLAB برای پردازش تصویر، شبیه‌سازی شبکه‌های عصبی، پردازش سیگنال‌های صوتی، پردازش متن و غیره استفاده می‌شود.

در کل، MATLAB یک ابزار بسیار قدرتمند است که در صنایع مختلف مورد استفاده قرار می‌گیرد. این نرم‌افزار به عنوان یک محیط محاسباتی و تحلیلی قدرتمند، به محققان و متخصصان می‌تواند در بسیاری از زمینه‌ها کمک کند و به دستیابی به نتایج بهتر و دقیق‌تر کمک کند.

نوشته کاربردهای نرم افزار متلب اولین بار در ايران متلب. پدیدار شد.

برای مشاهده لیست تمامی unit های پشیبانی شونده در نسخه متلب خود دستور زیر را در متلب وارد کنید.

> showunitslist

آموزش جامع سیمولینک simulink

نوشته مشاهده واحدهای پشتیبانی شونده در متلب اولین بار در ايران متلب. پدیدار شد.

یکی از مشکلاتی که در برنامه نویسی ممکن است به آن برخورد کنید، برخورد با کاراکتر ascii با کد 65279 می باشد.

این مشکل بیشر در هنگام خواندن فایلها رخ می دهد.

این مشکل ربطی به زبان برنامه نویسی شما ندارد در همه زبان های برنامه نویسی ممکن است رخ دهد.

این کاراکتر به اسم

zero-width no-break space

شناخته می شود و بیشتر هنگامی رخ می دهد که فایل شما به صورت
byte-order mark (BOM)
ذخیره شده باشد.

لذا کافی است که فایل خود را بدون این ویژگی ذخیره کنید.

مثلا فرض کنید من فایل زیر را می خوانم.

fid=fopen(‘retio.sr’,’r’);

با دستور زیر هر خط آنرا به ترتیب در یک حلقه می خوانم

tline = fgetl(fid)

فرض کنید عدد 1 در اولین خط آن قرار داشته باشد.

شما این خط را می خوانید و با کمال تعجب می بینید که چیزی که خواندید دارای 2 بعد می باشد.

بعد اول چیزی که خواندید همین کاراکتر اسکی 65279 می باشد.

اگر خروجی tline را چاپ کنید تنها عدد 1 را می بینید و این کد اسکی مخفی است.

برای دیدن این کد کافی است tline را به دستور double بفرستید.

نوشته این کاراکتر چیست؟ 65279 اولین بار در ايران متلب. پدیدار شد.

در شکل بالا یک درخت تصمیم ساده نشان داده شده است. این درخت تصمیم برای دسته بندی یک فرد بر اساس سه ویژگی ورزش و خوردن پیتزا و سن تشکیل شده است. خروجی این درخت تصمیم یکی از دو کلاس Fit و Unfit می باشد. از انواع درخت های تصمیم می توان C4.5 و C5 و Meta Decision Tree و Random Forest وJ48 را نام برد.

المانهای اصلی تشکیل دهنده یک درخت تصمیم :

Root Node (گره ریشه): اصلی ترین گره در درخت تصمیم می باشد و عملیات درخت تصمیم از این گره آغاز می شود. 

Decision Node (گره تصمیم گیری): گره هایی که به چند بخش تقسیم می شوند و متناسب با اندازه متغییر ورودی یکی از دو مسیر را مشخص می کنند. 

Leaf / Terminal Node (گره پایانی / برگ): گره های انتهایی یک درخت تصمیم هستند که اغلب مشخص کننده یکی از کلاسهای خروجی می باشند.

مزیت های درخت تصمیم :

• سادگی درک و تفسیر و نمایش
• امکان پیاده سازی سخت افزاری راحت
• قابلیت کار هم با داده های عددی و هم دسته بندی شده
• امکان مدلسازی مسئله های چند خروجی
• برعکس شبکه های عصبی که مثل یک جعبه سیاه هستند اما درخت تصمیم عملکرد آن به راحتی توسط شخص استفاده کننده، قابل درک است.

[button type=”big” color=”purple”] ارسال لینک های دانلود به ایمیل شما[/button]

این فیلم آموزشی اختصاص به پیاده سازی متلب درخت تصمیم دارد. این آموزش مناسب هر شخصی می باشد که می خواهد برنامه نویسی متلب درخت تصمیم را یاد بگیرد . شما به هیچ پیش نیاز ریاضی یا مهندسی برای این آموزش نیاز ندارید. به شما اطمینان می دهیم که از این آموزش نهایت لذت را ببرید.

محتوی این فیلم آموزشی :

در ابتدا مقداری تئوری درخت تصمیم گفته می شود، سپس برنامه نویسی مقدماتی با چندین مثال ساده شروع میشود و به مرور مثالهای کاملتری آموزش داده می شود. شما با نحوه نمایش یک درخت تصمیم در متلب هم آشنا می شوید. مثالهایی از cross-validation هم گفته می شود. عملیات هرس کردن pruning به صورت عملی در متلب پیاده سازی و مفهوم سطح هرس بیان می شود. سپس گزینه های قابل دسترس برای تنطمیمات درخت تصمیم در متلب گفته می شود و در نهایت نحوه بهینه سازی یک  درخت تصمیم به صورت عملی در متلب آموزش داده می شود. همراه با این آموزش 13 کد متلب درخت تصمیم هم قرار دارد که در آموزش خط به خط آنها توضیح کامل داده شده است. 

تعدادی از کدهای این آموزش را می توانید در GitHub ایران متلب مشاهده کنید:

https://github.com/PymatFlow/MATLABDecisionTree

پیش نمایش

دانلود پیش نمایش (کیفیت بالا)

مدت زمان : 214 دقیقه

لینک سفارش

نوشته برنامه نویسی متلب درخت تصمیم اولین بار در ايران متلب. پدیدار شد.

یکی از زمینه های بسیار جذاب و پرکاربرد در قرن اخیر هوش مصنوعی می باشد. هم اکنون کاربردهای بسیار زیادی برای هوش مصنوعی در جهان اطراف ما قابل مشاهده است مثل ماشین های بدون راننده ، دستیاران صوتی، مترجم های آنلاین، رباتهای هوشمند، نرم افزارهای تشخیص بیماری ، الگوریتم های هوشمند داده کاوی، تشخیص چهره، ربات سخن گو، پیش بینی بورس و نمودارهای مالی .

هوش مصنوعی دانش بسیار گسترده ای می باشد که بخشی از آن یادگیری عمیق می باشد. یادگیری عمیق یکی از موضوعات بسیار داغ و جذاب می باشد که علاقه مندان بسیار زیادی پیدا کرده است. یکی از دلایل این علاقه سادگی کار و نتایج حیرت کننده حاصل از آن می باشد. به عنوان مثال برای تشخیص یک شی در تصویر، اگر بخواهید از روشهای قدیمی استفاده کنید باید استخراج ویژگی انجام دهید و سپس یک مدل دسته بندی کننده انتخاب کنید. این فرایند بسیار زمان بر و تخصصی می باشد و می بایست یک فرد متخصص نوع ویژگی ها و پارامترهای آنها را تنظیم کند. اما با یادگیری عمیق شما فقط کافی است که ساختار مدل خود را طراحی کنید و نیازی به مرحله استخراج ویژگی ندارید و تمامی فرایند توسط لایه های مدل یادگیری عمیق انجام می شود.

دلیل بعدی جذابیت کار در یادگیری عمیق ، مدلهای آماده بسیار زیاد موجود می باشد که فرایند طراحی و آموزش و تست را بسیار کوتاه می کند و شما با توجه به مفهوم transfer learning یک مدل آماده را برای کاربرد خود تغییر می دهید. یعنی دیگر لازم نیست چرخ را از اول اختراع کنید و همه فرایند سخت و طاقت فرسای طراحی مدل هوشمند خود را از صفر شروع کنید. الان مدلهای آماده ای وجود دارند که با دقت بالایی می توانند 1000 کلاس مختلف تصویری را شناسایی کنند. یعنی شما مدل را import می کنید و تصویر بهش می دهید و برای شما کار شناسایی را انجام می دهد. به عبارت ساده تر هولو برو تو گلو. 🙂

لینک سفارش

قسمت اول

مبانی و مقدمات یادگیری عمیق

قسمت دوم

پیاده سازی و برنامه نویسی در متلب

مدرس :

قیصری (مدیر گروه ایران متلب با سابقه 15 ساله در متلب و زبان های مختلف برنامه نویسی)

نوشته بسته آموزشی جامع یادگیری عمیق Deep Learning اولین بار در ايران متلب. پدیدار شد.

امروزه پردازش های سیگنال های دیجیتال را در بیشتر ابزارهای اطراف خود از قبیل موبایل ، دوربین دیجیتال ، تبلت و تلویزیون و … استفاده می شود.

پردازندهای سیگنال دیجیتال سیگنال های دنیای واقعی مانند صدا ، صوت ، ویدئو ، دما ، فشار یا موقعیت را به فرم دیجیتال تبدیل می کنند و بر روی آنها عملیات ریاضی انجام می دهند.

تولباکس DSP متلب ، الگوریتم ها، ابزارهایی برای طراحی ، شبیه سازی و آنالیز سیستم های پردازش سیگنال در متلب و سیمولینک ارائه می دهد. شما می توانید از این تولباکس برای مدلسازی سیستم های DSP برخط مانند سیستم های مخابراتی ، رادار، صوتی ، وسایل پزشکی ، اینترنت اشیا و دیگر کاربردها استفاده کنید.

با این تولباکس شما می توانید فیلترهای وفقی ، چند مرحله ای ، چند نرخی ، IIR ، FIR را طراحی و آنالیز کنید. شما می توانید سیگنال ها را از متغییرها ، فایلهای دیتا و وسایل داخل شبکه وارد محیط متلب کنید.

این تولباکس ابزارهایی مانند اسکوپ (Time Scope) ، آنالیزر طیفی (Spectrum Analyzer)  ، آنالیز منطقی (Logical Analyzer) در اختیار شما قرار می دهد تا بتوانید به صورت دینامیک سیگنالها را مشاهده و اندازه گیری کنید.

لینک دانلود

معرفی این فیلم آموزشی :

لینک دانلود فیلم معرفی (کیفیت بالا)

نوشته آموزش فارسی پردازش سیگنال دیجیتال با متلب اولین بار در ايران متلب. پدیدار شد.

نوشته پیاده سازی متلب شبکه عصبی GoogLeNet اولین بار در ايران متلب. پدیدار شد.

لینک دانلود

نوشته پیاده سازی متلب شبکه عصبی AlexNet اولین بار در ايران متلب. پدیدار شد.

این کتابخانه بر روی متلب 2013a و بالاتر جواب می دهد.

نوشته کتابخانه سیمولینک Arduino اولین بار در ايران متلب. پدیدار شد.