我們在上篇筆記中介紹了感知機的，討論了感知機的由來、工作原理、求解策略、收斂性。這篇筆記中，我們親自動手寫代碼，使用感知機算法解決實際問題。

先從一個最簡單的問題開始，用感知機算法解決OR邏輯的分類。

import numpy as np
import matplotlib.pyplot as plt

x = [0,0,1,1]
y = [0,1,0,1]

plt.scatter(x[0],y[0], color="red",label="negative")
plt.scatter(x[1:],y[1:], color="green",label="positive")

plt.legend(loc="best")
plt.show()

下面我們來定義一個函數，用來判定一個樣本點是否被正確分類了。由於此例中樣本點是二維的，因此權重向量也相應的為二維，可以定義為\(w = (w_1, w_2)\)，在Python中可以使用列表來表達，例如w = [0, 0]，而樣本到超平面的距離自然就是w[0] * x[0] + w[1] * x[1] +b。下面給出完整的函數。

def decide(data,label,w,b):
    result = w[0] * data[0] + w[1] * data[1] - b
    print("result = ",result)
    if np.sign(result) * label <= 0:
        w[0] += 1 * (label - result) * data[0]
        w[1] += 1 * (label - result) * data[1]
        b += 1 * (label - result)*(-1)
    return w,b

寫完核心函數后，我們還需要寫一個調度函數，這個函數提供遍歷每一個樣本點的功能。

def run(data, label):
    w,b = [0,0],0
    for epoch in range(10):
        for item in zip(data, label):
            dataset,labelset = item[0],item[1]
            w,b = decide(dataset, labelset, w, b)
            print("dataset = ",dataset, ",", "w = ",w,",","b = ",b)
    print(w,b)

data = [(0,0),(0,1),(1,0),(1,1)]
label = [0,1,1,1]

run(data,label)

result =  0
dataset =  (0, 0) , w =  [0, 0] , b =  0
result =  0
dataset =  (0, 1) , w =  [0, 1] , b =  -1
result =  1
dataset =  (1, 0) , w =  [0, 1] , b =  -1
result =  2
dataset =  (1, 1) , w =  [0, 1] , b =  -1
result =  1
dataset =  (0, 0) , w =  [0, 1] , b =  0
result =  1
dataset =  (0, 1) , w =  [0, 1] , b =  0
result =  0
dataset =  (1, 0) , w =  [1, 1] , b =  -1
result =  3
dataset =  (1, 1) , w =  [1, 1] , b =  -1
result =  1
dataset =  (0, 0) , w =  [1, 1] , b =  0
result =  1
dataset =  (0, 1) , w =  [1, 1] , b =  0
result =  1
後面的迭代這裏省略不貼，參數穩定下來，算法已經收斂

下面看一個來自UCI的數據集：PIMA糖尿病數據集，例子來自《機器學習算法視角》第三章

import os
import pylab as pl
import numpy as np
import pandas as pd

os.chdir(r"DataSets\pima-indians-diabetes-database")

pima = np.loadtxt("pima.txt", delimiter=",", skiprows=1)

pima.shape

(768, 9)

indices0 = np.where(pima[:,8]==0)
indices1 = np.where(pima[:,8]==1)

pl.ion()
pl.plot(pima[indices0,0],pima[indices0,1],"go")
pl.plot(pima[indices1,0],pima[indices1,1],"rx")
pl.show()

數據預處理

1.將年齡離散化

pima[np.where(pima[:,7]<=30),7] = 1
pima[np.where((pima[:,7]>30) & (pima[:,7]<=40)),7] = 2
pima[np.where((pima[:,7]>40) & (pima[:,7]<=50)),7] = 3
pima[np.where((pima[:,7]>50) & (pima[:,7]<=60)),7] = 4
pima[np.where(pima[:,7]>60),7] = 5

2.將女性的懷孕次數大於8次的統一用8次代替

pima[np.where(pima[:,0]>8),0] = 8

3.將數據標準化處理

pima[:,:8] = pima[:,:8]-pima[:,:8].mean(axis=0)
pima[:,:8] = pima[:,:8]/pima[:,:8].var(axis=0)

4.切分訓練集和測試集

trainin = pima[::2,:8]
testin = pima[1::2,:8]
traintgt = pima[::2,8:9]
testtgt = pima[1::2,8:9]

定義模型

class Perceptron:
    def __init__(self, inputs, targets):
        # 設置網絡規模
        # 記錄輸入向量的維度，神經元的維度要和它相等
        if np.ndim(inputs) > 1:
            self.nIn = np.shape(inputs)[1]
        else:
            self.nIn = 1
        
        # 記錄目標向量的維度，神經元的個數要和它相等
        if np.ndim(targets) > 1:
            self.nOut = np.shape(targets)[1]
        else:
            self.nOut = 1
        
        # 記錄輸入向量的樣本個數
        self.nData = np.shape(inputs)[0]
        
        # 初始化網絡，這裏加1是為了包含偏置項
        self.weights = np.random.rand(self.nIn + 1, self.nOut) * 0.1 - 0.05
        
    def train(self, inputs, targets, eta, epoch):
        """訓練環節"""
        # 和前面處理偏置項同步地，這裏對輸入樣本加一項-1，與W0相匹配
        inputs = np.concatenate((inputs, -np.ones((self.nData,1))),axis=1)
        
        for n in range(epoch):
            self.activations = self.forward(inputs)
            self.weights -= eta * np.dot(np.transpose(inputs), self.activations - targets)
        return self.weights
    
    def forward(self, inputs):
        """神經網路前向傳播環節"""
        # 計算
        activations = np.dot(inputs, self.weights)
        # 判斷是否激活
        return np.where(activations>0, 1, 0)
    
    def confusion_matrix(self, inputs, targets):
        # 計算混淆矩陣
        inputs = np.concatenate((inputs, -np.ones((self.nData,1))),axis=1)
        outputs = np.dot(inputs, self.weights)
        nClasses = np.shape(targets)[1]
        
        if nClasses == 1:
            nClasses = 2
            outputs = np.where(outputs<0, 1, 0)
        else:
            outputs = np.argmax(outputs, 1)
            targets = np.argmax(targets, 1)
            
        cm = np.zeros((nClasses, nClasses))
        for i in range(nClasses):
            for j in range(nClasses):
                cm[i,j] = np.sum(np.where(outputs==i, 1,0) * np.where(targets==j, 1, 0))
        print(cm)
        print(np.trace(cm)/np.sum(cm))

print("Output after preprocessing of data")
p = Perceptron(trainin,traintgt)
p.train(trainin,traintgt,0.15,10000)
p.confusion_matrix(testin,testtgt)

Output after preprocessing of data
[[ 69.  86.]
 [182.  47.]]
0.3020833333333333

這個案例使用感知機訓練得到的結果比較糟糕，這裏只是作為展示算法的例子。

最後看一個使用感知機算法識別MNIST手寫数字的例子。代碼借鑒了Kaggle上的kernel。

step 1：首先導入所需的包，並且設置好數據所在路徑

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

train = pd.read_csv(r"DataSets\Digit_Recognizer\train.csv", engine="python")
test = pd.read_csv(r"DataSets\Digit_Recognizer\test.csv", engine="python")

print("Training set has {0[0]} rows and {0[1]} columns".format(train.shape))
print("Test set has {0[0]} rows and {0[1]} columns".format(test.shape))

Training set has 42000 rows and 785 columns
Test set has 28000 rows and 784 columns

step 2：數據預處理

1. 創建label，它的size為 (42000, 1)

2. 創建training set，size為(42000, 784)

3. 創建weights，size為（10，784），這可能有點不好理解。我們知道，權重向量是描述神經元的，784是維度，表示一個輸入樣本有784維，相應的與它對接的神經元也要有784維。同時，要記住一個神經元只能輸出一個output，而在数字識別問題中，我們期待的是輸入一個樣本數據，能返回10個数字，然後依概率判斷這個樣本是哪個数字的可能性最大。所以，我們需要10個神經元，這就是(10,784)的來歷。

trainlabels = train.label
trainlabels.shape

(42000,)

traindata = np.asmatrix(train.loc[:,"pixel0":])
traindata.shape

(42000, 784)

weights = np.zeros((10,784))
weights.shape

(10, 784)

這裏可以先看一個樣本，找找感覺。注意原數據是壓縮成了784維的數組，我們需要將它變回28*28的圖片

# 從矩陣中隨便取一行
samplerow = traindata[123:124]
# 重新變成28*28
samplerow = np.reshape(samplerow, (28,28))
plt.imshow(samplerow, cmap="hot")

step 3：訓練

這裏我們對訓練數據集循環若干次，然後重點關注錯誤率曲線

# 先創建一個列表，用來記錄每一輪訓練的錯誤率
errors = []
epoch = 20

for epoch in range(epoch):
    err = 0
    # 對每一個樣本（亦矩陣中的每一行）
    for i, data in enumerate(traindata):
        # 創建一個列表，用來記錄每個神經元輸出的值
        output = []
        # 對每個神經元都做點乘操作，並記錄下輸出值
        for w in weights:
            output.append(np.dot(data, w))
        # 這裏簡單的取輸出值最大者為最有可能的
        guess = np.argmax(output)
        # 實際的值為標籤列表中對應項
        actual = trainlabels[i]
        
        # 如果估計值和實際值不同，則分類錯誤，需要更新權重向量
        if guess != actual:
            weights[guess] = weights[guess] - data
            weights[actual] = weights[actual] + data
            err += 1
    # 計算迭代完42000個樣本之後，錯誤率 = 錯誤次數/樣本個數
    errors.append(err/42000)

x = list(range(20))
plt.plot(x, errors)

[<matplotlib.lines.Line2D at 0x5955c50>]

從圖可以看出，達到15次迭代時，錯誤率已經有上升的趨勢了，開始過擬合了。

感知機是一個非常簡單的算法，以致於很難在真正的場景中使用感知機算法。這裏舉的3個例子，都旨在於動手寫代碼實現這個算法，找找感覺。稍有經驗的讀者想必會好奇：為什麼沒有使用Scikit-Learn這個包，這部分其實是筆者另有計劃，打算結合算法寫Scikit-Learn的源碼解讀筆記。當然，限於個人水平，不一定能解析到精髓，但勉力而為吧。下篇會寫Multi-Layer-Perceptron算法的原理，在那裡我們很容易看到，縱使是簡單的感知機，只要加一個隱層，就能大幅提升其分類能力。另外，也會抽空寫一篇感知機Sklearn源碼解讀的文章。有任何問題，歡迎大家留言討論。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※信用卡的機場接送服務好嗎?

※台北桃園機場接送，網友超推，CP值超高，安全，寬敞又舒適

※想知道台東名產人氣商品是什麼?想知道更多台東知名伴手禮有哪些?

※評選台東伴手禮推薦商品「釋迦 」是台東必買伴手禮之一

※離島好好玩!小琉球必吃美食、必玩景點、最優惠的小琉球民宿套裝行程詳細攻略!

※濃郁的奶香牛軋糖-最好吃的伴手禮,送禮要送進心崁裡!

※找尋專業廣告設計,價格公道大圖輸出,背板品質佳

1. 創建線程的三種方法及其區別

1.1 繼承Thread類

首先，定義Thread類的子類並重寫run()方法：

package com.zwwhnly.springbootaction.javabase.thread;

public class MyFirstThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.printf("[MyFirstThread]輸出:%d,當前線程名稱:%s\n",
                    i, getName());
        }
    }
}

然後，創建該子類的實例並調用start()方法啟動線程：

package com.zwwhnly.springbootaction.javabase.thread;

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("主線程開始執行,當前線程名稱:" +
                Thread.currentThread().getName());

        Thread firstThread = new MyFirstThread();
        firstThread.start();

        System.out.println("主線程執行結束,當前線程名稱:" +
                Thread.currentThread().getName());
    }
}

運行結果如下所示：

主線程開始執行,當前線程名稱:main

主線程執行結束,當前線程名稱:main

[MyFirstThread]輸出:0,當前線程名稱:Thread-0

[MyFirstThread]輸出:1,當前線程名稱:Thread-0

[MyFirstThread]輸出:2,當前線程名稱:Thread-0

[MyFirstThread]輸出:3,當前線程名稱:Thread-0

[MyFirstThread]輸出:4,當前線程名稱:Thread-0

從運行結果可以看出以下2個問題：

1. 程序中存在2個線程，分別為主線程main和自定義的線程Thread-0。
2. 調用firstThread.start();，run()方法體中的代碼並沒有立即執行，而是異步執行的。

查看Thread類的源碼，可以發現Thread類實現了接口Runnable：

public class Thread implements Runnable {
    // 省略其它代碼
｝

這裡是重點，面試常問！

1.2 實現Runnable接口(推薦)

首先，定義Runnable接口的實現類並實現run()方法：

package com.zwwhnly.springbootaction.javabase.thread;

public class MySecondThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.printf("[MySecondThread]輸出:%d,當前線程名稱:%s\n",
                    i, Thread.currentThread().getName());
        }
    }
}

然後，調用Thread類的構造函數創建Thread實例並調用start()方法啟動線程：

package com.zwwhnly.springbootaction.javabase.thread;

public class ThreadTest {
    public static void main(String[] args) {
        Runnable target = new MySecondThread();
        Thread secondThread = new Thread(target);
        secondThread.start();
    }
}

運行結果如下所示：

主線程開始執行,當前線程名稱:main

主線程執行結束,當前線程名稱:main

[MySecondThread]輸出:0,當前線程名稱:Thread-0

[MySecondThread]輸出:1,當前線程名稱:Thread-0

[MySecondThread]輸出:2,當前線程名稱:Thread-0

[MySecondThread]輸出:3,當前線程名稱:Thread-0

[MySecondThread]輸出:4,當前線程名稱:Thread-0

可以看出，使用這種方式和繼承Thread類的運行結果是一樣的。

1.3 實現Callable接口

首先，定義Callable接口的實現類並實現call()方法：

package com.zwwhnly.springbootaction.javabase.thread;

import java.util.Random;
import java.util.concurrent.Callable;

public class MyThirdThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(6 * 1000);
        return new Random().nextInt();
    }
}

然後，調用FutureTask類的構造函數創建FutureTask實例：

Callable<Integer> callable = new MyThirdThread();
FutureTask<Integer> futureTask = new FutureTask<>(callable);

最後，調用Thread類的構造函數創建Thread實例並調用start()方法啟動線程：

package com.zwwhnly.springbootaction.javabase.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("主線程開始執行,當前線程名稱:" +
                Thread.currentThread().getName());

        Callable<Integer> callable = new MyThirdThread();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();

        try {
            System.out.println("futureTask.isDone() return:" + futureTask.isDone());

            System.out.println(futureTask.get());

            System.out.println("futureTask.isDone() return:" + futureTask.isDone());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("主線程執行結束,當前線程名稱:" +
                Thread.currentThread().getName());
    }
}

運行結果如下所示：

主線程開始執行,當前線程名稱:main

futureTask.isDone() return:false

-1193053528

futureTask.isDone() return:true

主線程執行結束,當前線程名稱:main

可以發現，使用Callable接口這種方式，我們可以通過futureTask.get()獲取到線程的執行結果，而之前的2種方式，都是沒有返回值的。

注意事項：調用futureTask.get()獲取線程的執行結果時，主線程會阻塞直到獲取到結果。

阻塞效果如下圖所示：

1.4 區別

以下是重點，面試常問！

1. Java中，類僅支持單繼承，如果一個類繼承了Thread類，就無法再繼承其它類，因此，如果一個類既要繼承其它的類，又必須創建為一個線程，就可以使用實現Runable接口的方式。
2. 使用實現Runable接口的方式創建的線程可以處理同一資源，實現資源的共享。
3. 使用實現Callable接口的方式創建的線程，可以獲取到線程執行的返回值、是否執行完成等信息。

關於第2點，可以通過如下示例來理解。

假如我們總共有10張票（共享的資源），為了提升售票的效率，開了3個線程來售賣，代碼如下所示：

package com.zwwhnly.springbootaction.javabase.thread;

public class SaleTicketThread implements Runnable {
    private int quantity = 10;

    @Override
    public void run() {
        while (quantity > 0) {
            System.out.println(quantity-- + " is saled by " +
                    Thread.currentThread().getName());
        }
    }
}

public static void main(String[] args) {
    Runnable runnable = new SaleTicketThread();
    Thread saleTicketThread1 = new Thread(runnable);
    Thread saleTicketThread2 = new Thread(runnable);
    Thread saleTicketThread3 = new Thread(runnable);

    saleTicketThread1.start();
    saleTicketThread2.start();
    saleTicketThread3.start();
}

因為3個線程都是異步執行的，因此每次的運行結果可能是不一樣，以下列舉2次不同的運行結果。

第1次運行結果：

10 is saled by Thread-0

8 is saled by Thread-0

7 is saled by Thread-0

5 is saled by Thread-0

9 is saled by Thread-1

3 is saled by Thread-1

2 is saled by Thread-1

1 is saled by Thread-1

4 is saled by Thread-0

6 is saled by Thread-2

第2次運行結果：

10 is saled by Thread-0

9 is saled by Thread-0

8 is saled by Thread-0

7 is saled by Thread-0

6 is saled by Thread-0

5 is saled by Thread-0

3 is saled by Thread-0

2 is saled by Thread-0

4 is saled by Thread-2

1 is saled by Thread-1

如果將上面的SaleTicketThread修改成繼承Thread類的方式，就變成了3個線程各自擁有10張票，即變成了30張票，而不是3個線程共享10張票。

2. Thread類start()和run()的區別

2.1 示例

因為實現Runnable接口的優勢，基本上實現多線程都使用的是該種方式，所以我們將之前定義的MyFirstThread也修改為實現Runnable接口的方式：

package com.zwwhnly.springbootaction.javabase.thread;

public class MyFirstThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.printf("[MyFirstThread]輸出:%d,當前線程名稱:%s\n",
                    i, Thread.currentThread().getName());
        }
    }
}

然後仍然沿用之前定義的MyFirstThread、MySecondThread，我們先看下調用start()的效果：

package com.zwwhnly.springbootaction.javabase.thread;

public class ThreadTest {
    public static void main(String[] args) {

        System.out.println("主線程開始執行,當前線程名稱:" +
                Thread.currentThread().getName());

        Thread firstThread = new Thread(new MyFirstThread());

        Runnable target = new MySecondThread();
        Thread secondThread = new Thread(target);

        firstThread.start();
        secondThread.start();

        System.out.println("主線程執行結束,當前線程名稱:" +
                Thread.currentThread().getName());
    }
}

運行結果（注意：多次運行，結果可能不一樣）：

主線程開始執行,當前線程名稱:main

[MyFirstThread]輸出:0,當前線程名稱:Thread-0

[MyFirstThread]輸出:1,當前線程名稱:Thread-0

[MySecondThread]輸出:0,當前線程名稱:Thread-1

主線程執行結束,當前線程名稱:main

[MySecondThread]輸出:1,當前線程名稱:Thread-1

[MySecondThread]輸出:2,當前線程名稱:Thread-1

[MySecondThread]輸出:3,當前線程名稱:Thread-1

[MySecondThread]輸出:4,當前線程名稱:Thread-1

[MyFirstThread]輸出:2,當前線程名稱:Thread-0

[MyFirstThread]輸出:3,當前線程名稱:Thread-0

[MyFirstThread]輸出:4,當前線程名稱:Thread-0

可以看出，調用start()方法后，程序中有3個線程，分別為主線程main、Thread-0、Thread-1，而且執行順序不是按順序執行的，存在不確定性。

然後將start()方法修改為run()方法，如下所示：

firstThread.run();
secondThread.run();

此時的運行結果如下所示（多次運行，結果是一樣的）：

主線程開始執行,當前線程名稱:main

[MyFirstThread]輸出:0,當前線程名稱:main

[MyFirstThread]輸出:1,當前線程名稱:main

[MyFirstThread]輸出:2,當前線程名稱:main

[MyFirstThread]輸出:3,當前線程名稱:main

[MyFirstThread]輸出:4,當前線程名稱:main

[MySecondThread]輸出:0,當前線程名稱:main

[MySecondThread]輸出:1,當前線程名稱:main

[MySecondThread]輸出:2,當前線程名稱:main

[MySecondThread]輸出:3,當前線程名稱:main

[MySecondThread]輸出:4,當前線程名稱:main

主線程執行結束,當前線程名稱:main

可以看出，調用run()方法后，程序中只有一個主線程，自定義的2個線程並沒有啟動，而且執行順序也是按順序執行的。

1.2 總結

以下是重點，面試常問！

• run()方法只是一個普通方法，調用之後程序會等待run()方法執行完畢，所以是串行執行，而不是并行執行。
• start()方法會啟動一個線程，當線程得到CPU資源後會自動執行run()方法體中的內容，實現真正的併發執行。

3. Runnable和Callable的區別

在文章前面的章節中（1.2 實現Runnable接口 和1.3 實現Callable接口），我們了解了如何使用Runnable、Callable接口來創建線程，現在我們分別看下Runable和Callable接口的定義，其中，Runable接口的定義如下所示：

public interface Runnable {
    public abstract void run();
}

Callable接口的定義如下所示：

public interface Callable<V> {
    V call() throws Exception;
}

由此可以看出，Runnable和Callable的區別主要有以下幾點：

1. Runable的執行方法是run()，Callable的執行方法是call()
2. call()方法可以拋出異常，run()方法如果有異常只能在內部消化
3. 實現Runnable接口的線程沒有返回值，實現Callable接口的線程能返回執行結果
4. 實現Callable接口的線程，可以和FutureTask一起使用，獲取到線程是否完成、線程是否取消、線程執行結果，也可以取消線程的執行。

4. 源碼及參考

源碼地址：，歡迎下載。

如果覺得文章寫的不錯，歡迎關注我的微信公眾號：「申城異鄉人」，所有博客會同步更新。

如果有興趣，也可以添加我的微信：zwwhnly_002，一起交流和探討技術。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※廣受好評的【機場接送推薦】

※租車接送服務需要另外加價嗎？

※台東人氣名產、台東人氣伴手禮,熱門獨家商品，現貨供應中

※坐月子經驗談-新竹到府坐月子媽媽心得分享與交流

※給婚攝的迎娶婚禮錄影必拍清單,沒拍到您一定會後悔!

※旅遊不求人,帶你掌握小琉球民宿海景攻略

※各類招牌、海報、大圖輸出,急件製作施工!

澤東新人李宛妲時尚首亮相

李宛妲Vanda以一組清新少女造型登上雜誌，原生態天然氣質與摩登混血的立體五官彼此加分，與眾不同的靈動生命力令這位15歲的女孩在陽光頗好的初春午後，令人眼前一亮。

李宛妲清新初春LOOK

18日，澤東電影宣告新人李宛妲的加入，她自此成為張震、張榕容的小師妹，同時也是澤東成立26年以來年紀最小的簽約演員。李宛妲帶着電影處女作《恭弘=叶 恭弘問4》正式入行，她在片中擔任女主角，與甄子丹飾演的恭弘=叶 恭弘問有不少對手戲。談及對未來的期待時，李宛妲表示，“我希望能學到很多東西，希望能夠靜一點，也希望自己越來越好。”

李宛妲首登時尚雜誌

被陽光偏愛的原生態少女

拍攝現場，李宛妲以清新初春LOOK顯露出專屬於15歲女孩的陽光與自信，而棒球外套、鴨舌帽、豹紋毛衣的不同搭配更讓人看到這位原生態少女的各種可能性。身處初春午後的李宛妲，與綠植親近互動，笑容明媚、自在隨性，仿若置身於她最熟悉和熱愛的家鄉——西雙版納。李宛妲03年出生於雲南，其父是從事西雙版納熱帶雨林修復和再造工作的德國生態學博士。她從與大自然相處的過程培養出獨特的性格，對現代與原始有不同的理解，也令她敢於大膽嘗試不同的時尚風格。“我小時候最喜歡那種誇張的風格，紅配綠，爆炸捲髮什麼的，現在的話，我覺得我什麼風格都可以嘗試。”

鏡頭前的李宛妲眼神清澈純凈，簡單的穿搭在她的演繹下完美詮釋出最舒服的少女狀態。對於生活與自然的認知，李宛妲皆在“都市定式”之外，她喜歡自己的小麥色皮膚，熱愛騎馬、射箭，且射箭為專業運動員的水平，而對於戶外活動的熱愛絲毫不影響她對家的眷顧。“手機對我而言是用來跟想念的人溝通，我特別喜歡阿米爾·汗的電影，因為他會用電影保護他的家、家人，是一種不一樣的精神。”如此心意，質樸又別樣。

澤東新簽最年輕藝人出任《恭弘=叶 恭弘問4》女主

李宛妲天然與現代感融合一體的特殊氣質，在她10歲時就曾吸引了知名攝影師肖全的鏡頭。肖全為她與姐姐拍了多組攝影作品並舉辦攝影展，而正是其中一組照片吸引到導演王家衛的目光，小女孩眉宇之間的質感讓他好奇Vanda的可能性，於是促成了她加入澤東電影，成為張震、張榕容的小師妹。據了解，正在學習舞蹈的李宛妲，已經被公司安排專門學習語文等不同功課，並有多個工作計劃將在今年爆發。

日前，李宛妲出席《恭弘=叶 恭弘問4》香港電影節記者會，這是她簽入澤東后的首度亮相。她在片中飾演出生於美國的華裔功夫少女若男，是吳樾扮演的太極堂堂主的女兒，與甄子丹飾演的恭弘=叶 恭弘問有不少對手戲，也因她的緣故激起了二人對武術的初心。該片是李宛妲的出道處女作，也是她第一次拍動作戲，處女作便擔女主，李宛妲很感謝前輩的提攜，“八爺、丹哥還有吳樾叔叔都很照顧我，讓我順利地完成表演。在這裏要謝謝他們，也希望不要給他們造成麻煩。”據悉，電影《恭弘=叶 恭弘問4》有望於今年上映，而新人演員李宛妲的大銀幕首秀也將與觀眾見面。

本站聲明:網站內容來源於江西熱線http://www.online.jx.cn,如有侵權請聯繫我們,我們將及時處理

【其他文章推薦】

※信用卡的機場接送服務好嗎?

※台北桃園機場接送，網友超推，CP值超高，安全，寬敞又舒適

※想知道台東名產人氣商品是什麼?想知道更多台東知名伴手禮有哪些?

※評選台東伴手禮推薦商品「釋迦 」是台東必買伴手禮之一

※離島好好玩!小琉球必吃美食、必玩景點、最優惠的小琉球民宿套裝行程詳細攻略!

※濃郁的奶香牛軋糖-最好吃的伴手禮,送禮要送進心崁裡!

※找尋專業廣告設計,價格公道大圖輸出,背板品質佳