परिचय
यदि मैं आपको सही तरीके से समझता हूं, तो आपको एक ऐसे उपयोगकर्ता की पहचान करने की आवश्यकता है जिसके पास आपके पास विशिष्ट पहचानकर्ता नहीं है, इसलिए आप यह पता लगाना चाहते हैं कि वे रैंडम डेटा का मिलान करके कौन हैं। आप उपयोगकर्ता की पहचान को विश्वसनीय रूप से संग्रहीत नहीं कर सकते क्योंकि:
- कुकीज़ को हटाया जा सकता है
- IP पता बदल सकते हैं
- ब्राउज़र बदल सकते हैं
- ब्राउज़र कैश हटाया जा सकता है
एक जावा एप्लेट या कॉम ऑब्जेक्ट हार्डवेयर जानकारी के हैश का उपयोग करके एक आसान समाधान होता, लेकिन इन दिनों लोग इतने सुरक्षा-जागरूक होते हैं कि लोगों को अपने सिस्टम पर इस प्रकार के कार्यक्रमों को स्थापित करना मुश्किल होगा। यह आपको कुकीज़ और अन्य समान उपकरणों का उपयोग करने से रोकता है।
कुकीज़ और अन्य, समान उपकरण
आप एक संभावित उपयोगकर्ता की पहचान करने के लिए प्रायिकता परीक्षणों का उपयोग करके डेटा प्रोफ़ाइल बनाने पर विचार कर सकते हैं । इसके लिए उपयोगी एक प्रोफ़ाइल निम्नलिखित के कुछ संयोजन द्वारा उत्पन्न की जा सकती है:
- आईपी पता
- रियल आईपी एड्रेस
- प्रॉक्सी IP पता (उपयोगकर्ता अक्सर एक ही प्रॉक्सी का बार-बार उपयोग करते हैं)
- कुकीज़
- वेब कीड़े (कम विश्वसनीय क्योंकि बग्स ठीक हो जाते हैं, लेकिन फिर भी उपयोगी हैं)
- पीडीएफ बग
- फ्लैश बग
- जावा बग
- ब्राउज़र्स
- ट्रैकिंग पर क्लिक करें (कई उपयोगकर्ता प्रत्येक विज़िट पर पृष्ठों की समान श्रृंखला पर जाते हैं)
- ब्राउज़र फिंगर प्रिंट - इंस्टॉल किए गए प्लगइन्स (लोगों के पास अक्सर अलग-अलग होते हैं, प्लगइन्स के कुछ विशिष्ट सेट)
- कैश्ड छवियां (लोग कभी-कभी अपनी कुकीज़ हटाते हैं लेकिन कैश्ड छवियों को छोड़ देते हैं)
- ब्लब्स का उपयोग करना
- URL (ब्राउज़र इतिहास या कुकीज़ में URLs में अद्वितीय उपयोगकर्ता आईडी हो सकते हैं, जैसे https://stackoverflow.com/users/1226894 या http://www.facebook.com/barackobama?fref=ts )
- सिस्टम फ़ॉन्ट्स डिटेक्शन (यह एक अल्पज्ञात लेकिन अक्सर विशिष्ट कुंजी हस्ताक्षर है)
- HTML5 और जावास्क्रिप्ट
- HTML5 लोकलस्टोरेज
- HTML5 जियोलोकेशन एपीआई और रिवर्स जियोकोडिंग
- वास्तुकला, OS भाषा, सिस्टम समय, स्क्रीन रिज़ॉल्यूशन, आदि।
- नेटवर्क सूचना एपीआई
- बैटरी स्थिति एपीआई
जिन वस्तुओं को मैंने सूचीबद्ध किया है, निश्चित रूप से, कुछ ही संभव तरीकों से उपयोगकर्ता को विशिष्ट रूप से पहचाना जा सकता है। और भी कई हैं।
रैंडम डेटा एलिमेंट्स के इस सेट से डेटा प्रोफाइल बनाने के लिए, आगे क्या है?
अगला कदम कुछ फजी लॉजिक विकसित करना है , या, अभी तक, एक कृत्रिम तंत्रिका नेटवर्क (जो फजी लॉजिक का उपयोग करता है)। या तो मामले में, विचार आपके सिस्टम को प्रशिक्षित करने के लिए है, और फिर अपने परिणामों की सटीकता को बढ़ाने के लिए बेइज़ियन इन्वेंशन के साथ अपने प्रशिक्षण को मिलाएं ।
NeuralMesh PHP के लिए पुस्तकालय आप कृत्रिम तंत्रिका नेटवर्क उत्पन्न करने के लिए अनुमति देता है। बायेसियन इंट्रेंस लागू करने के लिए, निम्नलिखित लिंक देखें:
इस बिंदु पर, आप सोच रहे होंगे:
एक सरल कार्य के लिए इतना गणित और तर्क क्यों?
मूल रूप से, क्योंकि यह एक सरल कार्य नहीं है । आप जो हासिल करने की कोशिश कर रहे हैं, वह वास्तव में शुद्ध संभावना है । उदाहरण के लिए, निम्नलिखित ज्ञात उपयोगकर्ताओं को दिया गया:
User1 = A + B + C + D + G + K
User2 = C + D + I + J + K + F
जब आप निम्नलिखित डेटा प्राप्त करते हैं:
B + C + E + G + F + K
प्रश्न जो आप अनिवार्य रूप से पूछ रहे हैं:
क्या संभावना है कि प्राप्त डेटा (B + C + E + G + F + K) वास्तव में User1 या User2 है? और उन दो मैचों में से कौन सबसे अधिक संभावित है?
इस प्रश्न का प्रभावी ढंग से उत्तर देने के लिए, आपको फ़्रिक्वेंसी बनाम प्रोबेबिलिटी प्रारूप को समझने की आवश्यकता है और संयुक्त संभावना एक बेहतर तरीका क्यों हो सकता है। यहाँ आने के लिए विवरण बहुत अधिक हैं (यही कारण है कि मैं आपको लिंक दे रहा हूँ), लेकिन एक अच्छा उदाहरण एक मेडिकल डायग्नोस्टिक विज़ार्ड है , जो संभावित बीमारियों की पहचान करने के लिए लक्षणों के संयोजन का उपयोग करता है।
डेटा बिंदुओं की श्रृंखला के एक पल के लिए सोचें, जिसमें आपके डेटा प्रोफाइल (बी + सी + ई + जी + एफ + के ऊपर उदाहरण में) लक्षण के रूप में हैं , और अज्ञात उपयोगकर्ता रोग के रूप में । बीमारी की पहचान करके, आप एक उपयुक्त उपचार (इस उपयोगकर्ता को उपयोगकर्ता 1 के रूप में मान सकते हैं) की पहचान कर सकते हैं।
जाहिर है, एक बीमारी जिसके लिए हमने 1 से अधिक लक्षणों की पहचान की है, पहचानना आसान है। वास्तव में, अधिक लक्षण हम पहचान कर सकते हैं, हमारा निदान उतना ही आसान और सटीक होगा।
क्या कोई अन्य विकल्प हैं?
बेशक। एक वैकल्पिक उपाय के रूप में, आप अपना स्वयं का सरल स्कोरिंग एल्गोरिथ्म बना सकते हैं, और इसे सटीक मिलानों पर आधारित कर सकते हैं। यह संभावना के रूप में कुशल नहीं है, लेकिन आपके लिए इसे लागू करना सरल हो सकता है।
एक उदाहरण के रूप में, इस सरल स्कोर चार्ट पर विचार करें:
+ ------------------------- + -------- + ------------ +
| संपत्ति | वजन | महत्व |
+ ------------------------- + -------- + ------------ +
| असली आईपी पता | 60 | 5 |
| प्रयुक्त प्रॉक्सी आईपी पता | 40 | 4 |
| HTTP कुकीज़ | 80 | 8 |
| सत्र कुकीज़ | 80 | 6 |
| 3 पार्टी कुकीज़ | 60 | 4 |
| फ्लैश कुकीज़ | 90 | 7 |
| पीडीएफ बग | 20 | 1 |
| फ्लैश बग | 20 | 1 |
| जावा बग | 20 | 1 |
| बार-बार पृष्ठ | 40 | 1 |
| ब्राउजर फिंगर प्रिंट | 35 | 2 |
| स्थापित प्लगइन्स | 25 | 1 |
| कैश्ड चित्र | 40 | 3 |
| URL | 60 | 4 |
| सिस्टम फ़ॉन्ट्स | 70 | 4 |
| लोकलस्टोरेज | 90 | 8 |
| जियोलोकेशन | 70 | 6 |
| AOLTR | 70 | 4 |
| नेटवर्क सूचना एपीआई | 40 | 3 |
| बैटरी की स्थिति एपीआई | 20 | 1 |
+ ------------------------- + -------- + ------------ +
जानकारी के प्रत्येक टुकड़े के लिए जिसे आप किसी दिए गए अनुरोध पर इकट्ठा कर सकते हैं, संबंधित स्कोर को पुरस्कृत कर सकते हैं, फिर जब स्कोर समान हो तो संघर्षों को हल करने के लिए महत्व का उपयोग करें ।
अवधारणा के सुबूत
अवधारणा के एक सरल प्रमाण के लिए, कृपया Perceptron पर एक नज़र डालें । पर्सेप्ट्रॉन एक आरएनए मॉडल है जो आमतौर पर पैटर्न मान्यता अनुप्रयोगों में उपयोग किया जाता है। एक पुरानी PHP क्लास भी है जो इसे पूरी तरह से लागू करती है, लेकिन आपको अपने उद्देश्यों के लिए इसे संशोधित करने की आवश्यकता होगी।
एक महान उपकरण होने के बावजूद, परसेप्ट्रॉन अभी भी कई परिणाम (संभावित मैच) लौटा सकता है, इसलिए स्कोर और अंतर की तुलना का उपयोग करना अभी भी उन मैचों में से सबसे अच्छा पहचानने के लिए उपयोगी है ।
मान्यताओं
- प्रत्येक उपयोगकर्ता (आईपी, कुकीज़, आदि) के बारे में सभी संभावित जानकारी संग्रहीत करें
- जहां परिणाम एक सटीक मैच है, स्कोर 1 से बढ़ाएं
- जहां परिणाम एक सटीक मैच नहीं है, स्कोर 1 से घटाएं
उम्मीद
- आरएनए लेबल उत्पन्न करें
- डेटाबेस का अनुकरण करने वाले यादृच्छिक उपयोगकर्ता उत्पन्न करें
- एकल अज्ञात उपयोगकर्ता उत्पन्न करें
- अज्ञात उपयोगकर्ता RNA और मान उत्पन्न करें
- सिस्टम आरएनए जानकारी को मर्ज कर देगा और परसेप्ट्रॉन को सिखाएगा
- Perceptron को प्रशिक्षण देने के बाद, सिस्टम में भार का एक सेट होगा
- अब आप अज्ञात उपयोगकर्ता के पैटर्न का परीक्षण कर सकते हैं और Perceptron एक परिणाम सेट का उत्पादन करेगा।
- सभी पॉजिटिव मैचों को स्टोर करें
- पहले अंकों को क्रम से, फिर अंतर के अनुसार क्रमबद्ध करें (जैसा ऊपर वर्णित है)
- दो निकटतम मैचों का आउटपुट, या, यदि कोई मैच नहीं मिला है, तो खाली परिणाम का उत्पादन करें
अवधारणा के प्रमाण के लिए कोड
$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 ";
}
आउटपुट:
Possible Match D (0.7416|0.16853),C (0.5393|0.2809)
"D" का Print_r:
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
)
यदि Debug = true आप इनपुट (सेंसर और वांछित), आरंभिक भार, आउटपुट (सेंसर, सम, नेटवर्क), त्रुटि, सुधार और अंतिम भार देख पाएंगे ।
+----+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+-----+----+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----------+
| 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 |
| -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
+----+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+-----+----+---------+---------+---------+---------+---------+---------+---------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----+----+----+----+----+----+----+----+----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----------+
X से X20 कोड द्वारा परिवर्तित सुविधाओं का प्रतिनिधित्व करते हैं।
// Get RNA Labels
$labels = array();
$n = 1;
foreach ( $features as $k => $v ) {
$labels[$k] = "x" . $n;
$n ++;
}
यहाँ एक ऑनलाइन डेमो है
कक्षा प्रयुक्त:
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;
}
}
संशोधित परसेप्ट्रॉन क्लास
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
निष्कर्ष
यूनीक आइडेंटिफायर के बिना यूजर की पहचान करना सीधा-सीधा या सरल काम नहीं है। यह रैंडम डेटा की पर्याप्त मात्रा को इकट्ठा करने पर निर्भर करता है, जिसे आप विभिन्न तरीकों से उपयोगकर्ता से इकट्ठा करने में सक्षम हैं।
यहां तक कि अगर आप एक कृत्रिम तंत्रिका नेटवर्क का उपयोग नहीं करने का चयन करते हैं, तो मैं सुझाव देता हूं कि प्राथमिकताओं और संभावना के साथ कम से कम एक साधारण संभाव्यता मैट्रिक्स का उपयोग करें - और मुझे आशा है कि ऊपर दिए गए कोड और उदाहरण आपको जाने के लिए पर्याप्त देते हैं।