饥荒lisp_目前，人工智能各个流派发展现状如何？

发展还是不错的但是想学习就需要有些基础

需要数学基础：

高等数学，线性代数，概率论数理统计和随机过程，离散数学，数值分析。数学基础知识蕴含着处理智能问题的基本思想与方法，也是理解复杂算法的必备要素。抄今天的种种人工智能技术归根到底都建立在数学模型之上，要了解人工智能，首先要掌握必备的数学基础知识。线性代数将研究对象形式化，概率论描述统计规律。

需要算法的积累：

人工神经网络，支持向量机，遗传算法等等算法；当然还有各个领域需要的算法，比如要让机器人自己在位置环境导航和建图就需要研究SLAM；总之算法很多需要时间的积累。

需要掌握至少一门编程语言：

比如C语言，MATLAB之类。毕竟算法的实现还是要编程的；如果深入到硬zhidao件的话，一些电类基础课必不可少。

最好去找一些系统的学习资料，这样你学起来会轻松很多

我这里有很多这方面的资料，有需要的可以参考下图找我

let exec_call opts stk state block call globals =

let Llair.{callee; actuals; areturn; return; recursive} = call in

let Llair.{name; formals; freturn; locals; entry} = callee in

[%Trace.call fun {pf} ->

pf "%a from %a with state@ %a" Llair.Reg.pp name.reg Llair.Reg.pp

return.dst.parent.name.reg Dom.pp state]

;

let dnf_states =

if opts.function_summaries then Dom.dnf state else [state]

in

let domain_call =

Dom.call ~globals ~actuals ~areturn ~formals ~freturn ~locals

in

List.fold ~init:Work.skip dnf_states ~f:(fun acc state ->

match

if not opts.function_summaries then None

else

let maybe_summary_post =

let state = fst (domain_call ~summaries:false state) in

let* summary = Hashtbl.find summary_table name.reg in

List.find_map ~f:(Dom.apply_summary state) summary

in

"Maybe summary post: %a" (Option.pp "%a" Dom.pp)

maybe_summary_post] ;

maybe_summary_post

with

| None ->

let state, from_call =

domain_call ~summaries:opts.function_summaries state

in

Work.seq acc

( match

Stack.push_call call ~bound:opts.bound from_call stk

with

| Some stk ->

Work.add stk ~prev:block ~retreating:recursive state entry

| None -> (

match Dom.recursion_beyond_bound with

| `skip -> Work.seq acc (exec_jump stk state block return)

| `prune -> Work.skip ) )

| Some post -> Work.seq acc (exec_jump stk post block return) )

|>

[%Trace.retn fun {pf} _ -> pf ""]

let pp_st () =

[%Trace.printf

"@[%t@]" (fun fs ->

Hashtbl.iteri summary_table ~f:(fun ~key ~data ->

Format.fprintf fs "@[%a:@ @[%a@]@]@ " Llair.Reg.pp key

(List.pp "@," Dom.pp_summary)

data ) )]

let exec_return ~opts stk pre_state (block : Llair.block) exp =

let Llair.{name; formals; freturn; locals} = block.parent in

[%Trace.call fun {pf} -> pf "from: %a" Llair.Reg.pp name.reg]

;

let summarize post_state =

if not opts.function_summaries then post_state

else

let globals =

Domain_used_globals.by_function opts.globals name.reg

in

let function_summary, post_state =

Dom.create_summary ~locals post_state

~formals:

(Llair.Reg.Set.union (Llair.Reg.Set.of_list formals) globals)

in

Hashtbl.add_multi summary_table ~key:name.reg ~data:function_summary ;

pp_st () ;

post_state

in

let exit_state =

match (freturn, exp) with

| Some freturn, Some return_val ->

Dom.exec_move pre_state (IArray.of_ (freturn, return_val))

| None, None -> pre_state

| _ -> violates Llair.Func.invariant block.parent

in

( match Stack.pop_return stk with

| Some (from_call, retn_site, stk) ->

let post_state = summarize (Dom.post locals from_call exit_state) in

let retn_state = Dom.retn formals freturn from_call post_state in

exec_jump stk retn_state block retn_site

| None ->

(* Create and store a function summary for main *)

if

opts.function_summaries

&& List.exists opts.entry_points

~f:(String.equal (Llair.Reg.name name.reg))

then summarize exit_state |> (ignore : Dom.t -> unit) ;

Work.skip )

|>

[%Trace.retn fun {pf} _ -> pf ""]