Analitik bir araç inşa ediyorum ve şu anda kullanıcı IP adresi, kullanıcı ajan tarayıcı ve işletim sistemi alabilirim.

Eğer çerezleri veya yerel depolama kullanmadan aynı kullanıcı tespit etmek için bir olasılık olup olmadığını merak ediyorum? Burada kod örnekleri beklemiyorum; sadece basit bir daha bakmak için ipucu.

Eğer aynı bilgisayar eğer çapraz tarayıcı uyumlu olması lazım, ki bunu söylemeyi unuttu/aygıt. Temelde tanıma cihazı değil gerçekten kullanıcı değilim.

Giriş

Doğru anladıysam eğer, Rasgele Verileri eşleştirerek kim olduklarını anlamaya istediğiniz kadar Benzersiz bir Tanımlayıcı yok kimin için bir kullanıcı tanımlamak gerekir. Kullanıcı kimliğini güvenilir bir şekilde saklamak:

• Çerezler silinmiş Olabilir
• IP adresini değiştirebilirsiniz
• Tarayıcı Değiştirebilirsiniz
• Tarayıcı Önbellek silinmiş olabilir

Bir Java Uygulaması veya Com Nesnesi olurdu kolay bir çözümü kullanarak, bir karma donanım bilgileri, ama bu günlerde insanlar bu yüzden güvenlik tanımayan bu güç insanlara yüklemek bu tür programlar kendi sistemi. Bu Çerezler ve diğer benzer araçları kullanarak ve seninle mahsur kalıyorum.

Çerezler ve diğer benzer araçlar

Veri Profil oluşturma, o zaman Olasılık testleri bir tanımlamak için kullanabilirsinizMuhtemel Kullanıcı. Profili yararlı bunun için aşağıdaki bazı kombinasyonu ile oluşturulabilir:

1. IP Adresi
   • Gerçek IP Adresi
   • Proxy IP Adresi (kullanıcılar sık sık tekrar tekrar aynı proxy kullanın)
2. Kurabiye
   • HTTP Çerezleri
   • Oturum Çerezleri
   • 3. Parti Çerezleri
   • Flash Çerezleri (most people don't know how to delete these)
3. Web Bugs (hatalar düzeltildi nedeniyle daha az güvenilir, ama yine de faydalı)
   • PDF Hata
   • Hata Flash
   • Java Hata
4. Tarayıcılar
   • Tıklama İzleme (birçok kullanıcı her ziyarette sayfaları aynı dizi ziyaret)
   • Tarayıcılar Parmak İzi - Eklentiler yüklü (insanlar genellikle, eklentileri biraz benzersiz ayarlar değişmiştir)
   • Önbelleğe alınan Resimler (insanlar bazen kendi çerezlerini sil ama önbelleğe görüntüleri bırakın)
   • Lekeler Kullanarak
   • (S) (tarayıcı geçmişi veya çerezleri URL benzersiz kullanıcı kimliği, http://stackoverflow.com/users/1226894 http://www.facebook.com/barackobama?fref=ts gibi içerebilir) URL
   • 22* *(Bu az bilinen ama genellikle benzersiz bir anahtar imzası)
5. HTML5 ve Javascript
   • HTML5 LocalStorage
   • HTML5 coğrafi konum API ve Ters coğrafi Kodlama
   • Mimari, Dil, Sistem Zaman, Ekran Çözünürlüğü, vb OS.
   • Ağ Bilgi API
   • Pil Durumu API

Ben listelenen öğeler, tabii ki, bir kullanıcı benzersiz olarak tanımlanabilir sadece birkaç olası yolu vardır. Çok fazla var.

Rastgele Veri elemanları bu set ile gelen Verileri bir Profil oluşturmak için, Sırada ne var?

Bir sonraki adım Fuzzy Logic, ya da, daha iyisi, Artificial Neural Network bulanık mantık kullanan) bir bazı geliştirmektir. Her iki durumda da, fikir sistemini eğitmek ve Bayesian Inference ile eğitim sonuçlarının doğruluğunu artırmak için birleştirir.

PHP için NeuralMesh kütüphane Yapay Sinir Ağları oluşturmasına olanak sağlar. Bayes Çıkarımı uygulamak için aşağıdaki bağlantılara bakın:

• Implement Bayesian inference using PHP, Part 1
• Implement Bayesian inference using PHP, Part 2
• Implement Bayesian inference using PHP, Part 3

Bu noktada, düşünce olabilir:

Neden görünüşte basit bir görev için çok fazla Matematik ve Mantık?

Çünkü temeldebasit bir iş değil. Elde etmeye çalıştığınız şey aslındaSaf Olasılık. Aşağıdaki bilinen kullanıcıları verilen örneğin:

User1 = A   B   C   D   G   K
User2 = C   D   I   J   K   F

Aşağıdaki veri aldığınızda:

B   C   E   G   F   K

Aslında soruyorsun eden soru budur:

Alınan veriler (E F K B C G) aslında User1 veya User2 olasılığı nedir? Ve bu iki maçenmuhtemel?

Etkin bir şekilde bu soruya cevap verebilmek için, Joint Probability daha iyi bir yaklaşım olabilir neden Frequency vs Probability Format ve anlamak gerekir. Detaylara çok fazla girmek burada (bu yüzden sana veriyorum bağlantılar), ama iyi bir örnek olurdu Medical Diagnosis Wizard Application kullandığı bir kombinasyon belirtileri tanımlamak mümkün olan hastalıklar.

Veri dizisinin bir an olarak Veri Profil (E F örnekte K B C G üzeri) oluşturan noktaları düşünüyorumBelirtilerve Bilinmeyen Kullanıcı olarakHastalıkları. Hastalık tespit ederek, daha uygun bir tedavi (Bu kullanıcı Kullanıcı1 tedavi) belirleyebilirsiniz.

Belli ki, birHastalıkkendisi için 1'den fazla tespit ettikBelirtidaha kolay tanımlamak için. Aslında, daha fazlaBelirtilerteşhis, tanı koymak için neredeyse kesindir daha kolay ve daha doğru yapabiliriz.

Başka bir alternatif var mı?

Elbette. Alternatif bir tedbir olarak, kendi basit algoritma Puanlama oluşturabilirsiniz, ve taban üzerine tam uyuyor. Bu olasılık kadar verimli değil, ama uygulamak için daha basit olabilir.

Örnek olarak, bu basit puan grafiği göz önünde bulundurun:

 ------------------------- -------- ------------ 
|        Property         | Weight | Importance |
 ------------------------- -------- ------------ 
| Real IP address         |     60 |          5 |
| Used proxy IP address   |     40 |          4 |
| HTTP Cookies            |     80 |          8 |
| Session Cookies         |     80 |          6 |
| 3rd Party Cookies       |     60 |          4 |
| Flash Cookies           |     90 |          7 |
| PDF Bug                 |     20 |          1 |
| Flash Bug               |     20 |          1 |
| Java Bug                |     20 |          1 |
| Frequent Pages          |     40 |          1 |
| Browsers Finger Print   |     35 |          2 |
| Installed Plugins       |     25 |          1 |
| Cached Images           |     40 |          3 |
| URL                     |     60 |          4 |
| System Fonts Detection  |     70 |          4 |
| Localstorage            |     90 |          8 |
| Geolocation             |     70 |          6 |
| AOLTR                   |     70 |          4 |
| Network Information API |     40 |          3 |
| Battery Status API      |     20 |          1 |
 ------------------------- -------- ------------ 

Belirli bir istek üzerine toplayabilir hangi bilgilerin her parça için, ilgili puan ödülü kullanınÖnemipuanları aynı olduğunda çatışmaları çözmek için.

Kavram kanıtı

Kavram basit bir ispat için, lütfen Perceptron bir göz atın. Algılayıcı genellikle örüntü tanıma uygulamalarında kullanılan RNA Model. Hatta mükemmel bir şekilde uygulayan PHP Class bir eski var, ama büyük olasılıkla amaçlar için değiştirmek gerekir.

Büyük bir araç olmasına rağmen, hala birden çok Algılayıcı sonuçları (eşleşme) iade edebilir, Skor ve Fark bir karşılaştırma kullanarak hala yararlı belirlemektiriyio maçları.

Varsayımlar

• Mağaza her kullanıcı hakkında mümkün olan tüm bilgileri (İP, çerezler, vb.)
• Sonuç tam bir eşleşme olduğu, 1 puan artış
• Sonuç tam bir eşleşme değil, 1 puan düşüş

Beklenti

1. RNA etiketler oluşturmak
2. Bir veritabanı taklit rastgele kullanıcılar oluşturmak
3. Tek Bilinmeyen bir kullanıcı oluşturmak
4. Bilinmeyen kullanıcı RNA oluşturmak ve Değerleri
5. Sistem RNA bilgileri birleştirme ve Algılayıcı öğretecek
6. Bu Algılayıcı eğitimden sonra, sistem ağırlıkları bir dizi olacak
7. Şimdi Bilinmeyen kullanıcıya test edebilirsiniz ve Algılayıcı bir sonuç çıkarır.
8. Tüm Olumlu maçlar mağaza
9. İlk Puanı maçlar sıralama, o zaman Fark (yukarıda açıklandığı gibi)
10. Çıkış iki yakın eşleşme, ya da, eğer hiçbir eşleşme bulunursa, boş bir sonuç çıktı

Kavram Kanıtı için kod

$features = array(
    'Real IP address' => .5,
    'Used proxy IP address' => .4,
    'HTTP Cookies' => .9,
    'Session Cookies' => .6,
    '3rd Party Cookies' => .6,
    'Flash Cookies' => .7,
    'PDF Bug' => .2,
    'Flash Bug' => .2,
    'Java Bug' => .2,
    'Frequent Pages' => .3,
    'Browsers Finger Print' => .3,
    'Installed Plugins' => .2,
    'URL' => .5,
    'Cached PNG' => .4,
    'System Fonts Detection' => .6,
    'Localstorage' => .8,
    'Geolocation' => .6,
    'AOLTR' => .4,
    'Network Information API' => .3,
    'Battery Status API' => .2
);

// Get RNA Lables
$labels = array();
$n = 1;
foreach ($features as $k => $v) {
    $labels[$k] = "x" . $n;
    $n   ;
}

// Create Users
$users = array();
for($i = 0, $name = "A"; $i < 5; $i   , $name   ) {
    $users[] = new Profile($name, $features);
}

// Generate Unknown User
$unknown = new Profile("Unknown", $features);

// Generate Unknown RNA
$unknownRNA = array(
    0 => array("o" => 1),
    1 => array("o" => - 1)
);

// Create RNA Values
foreach ($unknown->data as $item => $point) {
    $unknownRNA[0][$labels[$item]] = $point;
    $unknownRNA[1][$labels[$item]] = (- 1 * $point);
}

// Start Perception Class
$perceptron = new Perceptron();

// Train Results
$trainResult = $perceptron->train($unknownRNA, 1, 1);

// Find matches
foreach ($users as $name => &$profile) {
    // Use shorter labels
    $data = array_combine($labels, $profile->data);
    if ($perceptron->testCase($data, $trainResult) == true) {
        $score = $diff = 0;

        // Determing the score and diffrennce
        foreach ($unknown->data as $item => $found) {
            if ($unknown->data[$item] === $profile->data[$item]) {
                if ($profile->data[$item] > 0) {
                    $score  = $features[$item];
                } else {
                    $diff  = $features[$item];
                }
            }
        }
        // Ser score and diff
        $profile->setScore($score, $diff);
        $matchs[] = $profile;
    }
}

// Sort bases on score and Output
if (count($matchs) > 1) {
    usort($matchs, function ($a, $b) {
        // If score is the same use diffrence
        if ($a->score == $b->score) {
            // Lower the diffrence the better
            return $a->diff == $b->diff ? 0 : ($a->diff > $b->diff ? 1 : - 1);
        }
        // The higher the score the better
        return $a->score > $b->score ? - 1 : 1;
    });

    echo "<br />Possible Match ", implode(",", array_slice(array_map(function ($v) {
        return sprintf(" %s (%0.4f|%0.4f) ", $v->name, $v->score,$v->diff);
    }, $matchs), 0, 2));
} else {
    echo "<br />No match Found ";
}

Output:

Possible Match D (0.7416|0.16853),C (0.5393|0.2809)

Print_r "D":

echo "<pre>";
print_r($matchs[0]);


Profile Object(
    [name] => D
    [data] => Array (
        [Real IP address] => -1
        [Used proxy IP address] => -1
        [HTTP Cookies] => 1
        [Session Cookies] => 1
        [3rd Party Cookies] => 1
        [Flash Cookies] => 1
        [PDF Bug] => 1
        [Flash Bug] => 1
        [Java Bug] => -1
        [Frequent Pages] => 1
        [Browsers Finger Print] => -1
        [Installed Plugins] => 1
        [URL] => -1
        [Cached PNG] => 1
        [System Fonts Detection] => 1
        [Localstorage] => -1
        [Geolocation] => -1
        [AOLTR] => 1
        [Network Information API] => -1
        [Battery Status API] => -1
    )
    [score] => 0.74157303370787
    [diff] => 0.1685393258427
    [base] => 8.9
)

Eğer = true hata Ayıklama Input (Sensor & Desired), Initial Weights, Output (Sensor, Sum, Network), Error, Correction and Final Weights görmek mümkün olacaktır.

 ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ------ ----- ---- --------- --------- --------- --------- --------- --------- --------- --------- --------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----------- 
| o  | x1 | x2 | x3 | x4 | x5 | x6 | x7 | x8 | x9 | x10 | x11 | x12 | x13 | x14 | x15 | x16 | x17 | x18 | x19 | x20 | Bias | Yin | Y  | deltaW1 | deltaW2 | deltaW3 | deltaW4 | deltaW5 | deltaW6 | deltaW7 | deltaW8 | deltaW9 | deltaW10 | deltaW11 | deltaW12 | deltaW13 | deltaW14 | deltaW15 | deltaW16 | deltaW17 | deltaW18 | deltaW19 | deltaW20 | W1 | W2 | W3 | W4 | W5 | W6 | W7 | W8 | W9 | W10 | W11 | W12 | W13 | W14 | W15 | W16 | W17 | W18 | W19 | W20 | deltaBias |
 ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ------ ----- ---- --------- --------- --------- --------- --------- --------- --------- --------- --------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----------- 
| 1  | 1  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1    | 0   | -1 | 0       | -1      | -1      | -1      | -1      | -1      | -1      | 1       | 1       | 1        | 1        | 1        | 1        | 1        | -1       | -1       | -1       | -1       | 1        | 1        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -1 | -1 | 1  | 1  | 1  | 1  | 1  | 1  | -1 | -1 | -1  | -1  | -1  | -1  | -1  | 1   | 1   | 1   | 1   | -1  | -1  | 1    | -19 | -1 | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --   | --  | -- | --      | --      | --      | --      | --      | --      | --      | --      | --      | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --        |
| 1  | 1  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1    | 19  | 1  | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -1 | -1 | 1  | 1  | 1  | 1  | 1  | 1  | -1 | -1 | -1  | -1  | -1  | -1  | -1  | 1   | 1   | 1   | 1   | -1  | -1  | 1    | -19 | -1 | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0       | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0        | 0  | -1 | -1 | -1 | -1 | -1 | -1 | 1  | 1  | 1   | 1   | 1   | 1   | 1   | -1  | -1  | -1  | -1  | 1   | 1   | 1         |
| -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --   | --  | -- | --      | --      | --      | --      | --      | --      | --      | --      | --      | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | --       | -- | -- | -- | -- | -- | -- | -- | -- | -- | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --  | --        |
 ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ------ ----- ---- --------- --------- --------- --------- --------- --------- --------- --------- --------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---------- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----------- 

x20 için x1 özellikleri kod tarafından dönüştürülmüş temsil eder.

// Get RNA Labels
$labels = array();
$n = 1;
foreach ( $features as $k => $v ) {
    $labels[$k] = "x" . $n;
    $n   ;
}

Burada online demo

Sınıf:

class Profile {
    public $name, $data = array(), $score, $diff, $base;

    function __construct($name, array $importance) {
        $values = array(-1, 1); // Perception values
        $this->name = $name;
        foreach ($importance as $item => $point) {
            // Generate Random true/false for real Items
            $this->data[$item] = $values[mt_rand(0, 1)];
        }
        $this->base = array_sum($importance);
    }

    public function setScore($score, $diff) {
        $this->score = $score / $this->base;
        $this->diff = $diff / $this->base;
    }
}

Algılayıcı Sınıfı Değiştirilmiş

class Perceptron {
    private $w = array();
    private $dw = array();
    public $debug = false;

    private function initialize($colums) {
        // Initialize perceptron vars
        for($i = 1; $i <= $colums; $i   ) {
            // weighting vars
            $this->w[$i] = 0;
            $this->dw[$i] = 0;
        }
    }

    function train($input, $alpha, $teta) {
        $colums = count($input[0]) - 1;
        $weightCache = array_fill(1, $colums, 0);
        $checkpoints = array();
        $keepTrainning = true;

        // Initialize RNA vars
        $this->initialize(count($input[0]) - 1);
        $just_started = true;
        $totalRun = 0;
        $yin = 0;

        // Trains RNA until it gets stable
        while ($keepTrainning == true) {
            // Sweeps each row of the input subject
            foreach ($input as $row_counter => $row_data) {
                // Finds out the number of columns the input has
                $n_columns = count($row_data) - 1;

                // Calculates Yin
                $yin = 0;
                for($i = 1; $i <= $n_columns; $i   ) {
                    $yin  = $row_data["x" . $i] * $weightCache[$i];
                }

                // Calculates Real Output
                $Y = ($yin <= 1) ? - 1 : 1;

                // Sweeps columns ...
                $checkpoints[$row_counter] = 0;
                for($i = 1; $i <= $n_columns; $i   ) {
                    /** DELTAS **/
                    // Is it the first row?
                    if ($just_started == true) {
                        $this->dw[$i] = $weightCache[$i];
                        $just_started = false;
                        // Found desired output?
                    } elseif ($Y == $row_data["o"]) {
                        $this->dw[$i] = 0;
                        // Calculates Delta Ws
                    } else {
                        $this->dw[$i] = $row_data["x" . $i] * $row_data["o"];
                    }

                    /** WEIGHTS **/
                    // Calculate Weights
                    $this->w[$i] = $this->dw[$i]   $weightCache[$i];
                    $weightCache[$i] = $this->w[$i];

                    /** CHECK-POINT **/
                    $checkpoints[$row_counter]  = $this->w[$i];
                } // END - for

                foreach ($this->w as $index => $w_item) {
                    $debug_w["W" . $index] = $w_item;
                    $debug_dw["deltaW" . $index] = $this->dw[$index];
                }

                // Special for script debugging
                $debug_vars[] = array_merge($row_data, array(
                    "Bias" => 1,
                    "Yin" => $yin,
                    "Y" => $Y
                ), $debug_dw, $debug_w, array(
                    "deltaBias" => 1
                ));
            } // END - foreach

            // Special for script debugging
             $empty_data_row = array();
            for($i = 1; $i <= $n_columns; $i   ) {
                $empty_data_row["x" . $i] = "--";
                $empty_data_row["W" . $i] = "--";
                $empty_data_row["deltaW" . $i] = "--";
            }
            $debug_vars[] = array_merge($empty_data_row, array(
                "o" => "--",
                "Bias" => "--",
                "Yin" => "--",
                "Y" => "--",
                "deltaBias" => "--"
            ));

            // Counts training times
            $totalRun   ;

            // Now checks if the RNA is stable already
            $referer_value = end($checkpoints);
            // if all rows match the desired output ...
            $sum = array_sum($checkpoints);
            $n_rows = count($checkpoints);
            if ($totalRun > 1 && ($sum / $n_rows) == $referer_value) {
                $keepTrainning = false;
            }
        } // END - while

        // Prepares the final result
        $result = array();
        for($i = 1; $i <= $n_columns; $i   ) {
            $result["w" . $i] = $this->w[$i];
        }

        $this->debug($this->print_html_table($debug_vars));

        return $result;
    } // END - train
    function testCase($input, $results) {
        // Sweeps input columns
        $result = 0;
        $i = 1;
        foreach ($input as $column_value) {
            // Calculates teste Y
            $result  = $results["w" . $i] * $column_value;
            $i   ;
        }
        // Checks in each class the test fits
        return ($result > 0) ? true : false;
    } // END - test_class

    // Returns the html code of a html table base on a hash array
    function print_html_table($array) {
        $html = "";
        $inner_html = "";
        $table_header_composed = false;
        $table_header = array();

        // Builds table contents
        foreach ($array as $array_item) {
            $inner_html .= "<tr>\n";
            foreach ( $array_item as $array_col_label => $array_col ) {
                $inner_html .= "<td>\n";
                $inner_html .= $array_col;
                $inner_html .= "</td>\n";

                if ($table_header_composed == false) {
                    $table_header[] = $array_col_label;
                }
            }
            $table_header_composed = true;
            $inner_html .= "</tr>\n";
        }

        // Builds full table
        $html = "<table border=1>\n";
        $html .= "<tr>\n";
        foreach ($table_header as $table_header_item) {
            $html .= "<td>\n";
            $html .= "<b>" . $table_header_item . "</b>";
            $html .= "</td>\n";
        }
        $html .= "</tr>\n";

        $html .= $inner_html . "</table>";

        return $html;
    } // END - print_html_table

    // Debug function
    function debug($message) {
        if ($this->debug == true) {
            echo "<b>DEBUG:</b> $message";
        }
    } // END - debug
} // END - class

Sonuç

Benzersiz bir Tanımlayıcı olmayan bir kullanıcı tanımlama-ileri düz veya basit bir görev değildir. çeşitli yöntemlerle kullanıcı toplamak için mümkün olan Rasgele yeterli miktarda Veri toplamak bağlıdır.

Bile tercih değil, bir Yapay Sinir Ağı, öneririm en azından kullanarak Basit bir Olasılık Matris ile öncelikler ve likelihoods - ve umarım kod ve örnekler verilen yukarıda vermeniz yeterli.