文本演算法
1. 文本自動分類演算法有哪些呢
文本自動分類演算法主要有樸素貝葉斯分類演算法、支持向量機分類演算法、KNN演算法和決策樹演算法。
樸素貝葉斯分類演算法主要是利用文本中詞的特徵項和類別的組合概率來估算文本屬於哪個類別的概率。
支持向量機分類算分主要是採用特徵提取技術把文本信息轉換為詞向量，然後用詞向量與訓練好的類別數據進行相似度計算。
KNN演算法是在訓練集中找到離它最近的k個文本，並根據這些文本的分類來預測待分類文本屬於哪一個類別。
決策樹演算法是首先建立一個基於樹的預測模型，根據預測模型來對文本進行預測分類。
2. 深度學習演算法哪些適用於文本處理
作者：梅洪源
來源：知乎
現在實踐證明，對supervised-learning而言，效果較好的應該算是Recurrent Neural Network （RNN）吧，目前比較火的一類RNN是LSTM -- Long Short Term Memory。
對於這個model而言，最初的發明見於論文--Long Short Term Memory by Hochreiter and Schmidhuber，而之後較好的歸納和實現可以參考Frame Phoneme Classification with Bidirectional LSTM by Alex Graves，後者有比較清晰的back propagation的公式。
最近兩年這個model在speech，language以及multimodal with vision等方面可謂是大展宏圖，一再的刷新實驗結果，重要工作可以參考：
Speech recognition with Deep Recurrent Neural Networks by Graves
Sequence to Sequence Learning with Neural Networks by Sutskever
Show Attend and Tell by Kelvin Xu
至於具體的實現，希望避免造輪子的可以參考這個非常famous的github：karpathy (Andrej) · GitHub，Andrej Karpathy最近發了很多很有趣的RNN的fun project，可以borrow一些代碼。
希望自己造輪子的，可以選擇用Theano或者Torch，用畫data flow的方法來code整個structure，很簡潔實用，我個人一直用Theano，給個好評。：）
當然啦，至於你要研究什麼問題，還是具體問題具體分析的好。可以去搜搜有沒有研究類似問題的paper，看看目前的最好的技術是什麼。Deep Learning不一定是萬能的啦。
3. 易語言查找演算法，求高人進，我寫了一個在文件里查找文本的演算法，是這...
不造你是不是要做閱讀器
好吧給你個思路 你先把文本長度讀出來 取文本長度（）這個方法會用吧
然後給它分割成若幹部分，比如分割原文本長度的1/2 這個會吧？取文本左邊（）這個方法。
然後再取文本右邊（）取到剩下的一半 ，再對這兩部分依次重復一次， 每次取一半分割成4部分 然後開四個線程分割換行符或者啥的，再循環查找。要是四部分不夠效率繼續分下去，分成8個。16個。。。這樣是最簡單的解決辦法 。
4. 文本比較有哪些演算法
用java比較兩個文本文件的不同
RangeDifferencer
public class RangeDifferencer {
private static final RangeDifference[] EMPTY_RESULT= new RangeDifference[0];
/* (non Javadoc)
* Cannot be instantiated!
*/
private RangeDifferencer() {
// nothing to do
}
/**
* Finds the differences between two <code>IRangeComparator</code>s.
* The differences are returned as an array of <code>RangeDifference</code>s.
* If no differences are detected an empty array is returned.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences, or an empty array if no differences were found
*/
public static RangeDifference[] findDifferences(IRangeComparator left, IRangeComparator right) {
int rightSize= right.getRangeCount();
int leftSize= left.getRangeCount();
//
// Differences matrix:
// only the last d of each diagonal is stored, i.e., lastDiagonal[k] = row of d
//
int diagLen= 2 * Math.max(rightSize, leftSize); // bound on the size of edit script
int maxDiagonal= diagLen;
int lastDiagonal[]= new int[diagLen + 1]; // the row containing the last d
// on diagonal k (lastDiagonal[k] = row)
int origin= diagLen / 2; // origin of diagonal 0
// script corresponding to d[k]
LinkedRangeDifference script[]= new LinkedRangeDifference[diagLen + 1];
int row, col;
// find common prefix
for (row= 0; row < rightSize && row < leftSize && rangesEqual(right, row, left, row) == true;)
row++;
lastDiagonal[origin]= row;
script[origin]= null;
int lower= (row == rightSize) ? origin + 1 : origin - 1;
int upper= (row == leftSize) ? origin - 1 : origin + 1;
if (lower > upper)
return EMPTY_RESULT;
//System.out.println("findDifferences: " + maxDiagonal + " " + lower + " " + upper);
// for each value of the edit distance
for (int d= 1; d <= maxDiagonal; ++d) { // d is the current edit distance
if (right.skipRangeComparison(d, maxDiagonal, left))
return EMPTY_RESULT; // should be something we already found
// for each relevant diagonal (-d, -d+2 ..., d-2, d)
for (int k= lower; k <= upper; k += 2) { // k is the current diagonal
LinkedRangeDifference edit;
if (k == origin - d || k != origin + d && lastDiagonal[k + 1] >= lastDiagonal[k - 1]) {
//
// move down
//
row= lastDiagonal[k + 1] + 1;
edit= new LinkedRangeDifference(script[k + 1], LinkedRangeDifference.DELETE);
} else {
//
// move right
//
row= lastDiagonal[k - 1];
edit= new LinkedRangeDifference(script[k - 1], LinkedRangeDifference.INSERT);
}
col= row + k - origin;
edit.fRightStart= row;
edit.fLeftStart= col;
//Assert.isTrue(k >= 0 && k <= maxDiagonal);
script[k]= edit;
// slide down the diagonal as far as possible
while (row < rightSize && col < leftSize && rangesEqual(right, row, left, col) == true) {
++row;
++col;
}
//Assert.isTrue(k >= 0 && k <= maxDiagonal); // Unreasonable value for diagonal index
lastDiagonal[k]= row;
if (row == rightSize && col == leftSize) {
//showScript(script[k], right, left);
return createDifferencesRanges(script[k]);
}
if (row == rightSize)
lower= k + 2;
if (col == leftSize)
upper= k - 2;
}
--lower;
++upper;
}
// too many differences
//Assert.isTrue(false);
return null;
}
/**
* Finds the differences among two <code>IRangeComparator</code>s.
* In contrast to <code>findDifferences</code>, the result
* contains <code>RangeDifference</code> elements for non-differing ranges too.
*
* @param left the left range comparator
* @param right the right range comparator
* @return an array of range differences
*/
public static RangeDifference[] findRanges(IRangeComparator left, IRangeComparator right) {
RangeDifference[] in= findDifferences(left, right);
List out= new ArrayList();
RangeDifference rd;
int mstart= 0;
int ystart= 0;
for (int i= 0; i < in.length; i++) {
RangeDifference es= in[i];
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, es.rightStart() - mstart, ystart, es.leftStart() - ystart);
if (rd.maxLength() != 0)
out.add(rd);
out.add(es);
mstart= es.rightEnd();
ystart= es.leftEnd();
}
rd= new RangeDifference(RangeDifference.NOCHANGE, mstart, right.getRangeCount() - mstart, ystart, left.getRangeCount() - ystart);
if (rd.maxLength() > 0)
out.add(rd);
return (RangeDifference[]) out.toArray(EMPTY_RESULT);
}
//---- private methods
/*
* Creates a Vector of DifferencesRanges out of the LinkedRangeDifference.
* It coalesces adjacent changes.
* In addition, indices are changed such that the ranges are 1) open, i.e,
* the end of the range is not included, and 2) are zero based.
*/
private static RangeDifference[] createDifferencesRanges(LinkedRangeDifference start) {
LinkedRangeDifference ep= reverseDifferences(start);
ArrayList result= new ArrayList();
RangeDifference es= null;
while (ep != null) {
es= new RangeDifference(RangeDifference.CHANGE);
if (ep.isInsert()) {
es.fRightStart= ep.fRightStart + 1;
es.fLeftStart= ep.fLeftStart;
RangeDifference b= ep;
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fRightStart= ep.fRightStart;
es.fLeftStart= ep.fLeftStart;
RangeDifference a= ep;
//
// deleted lines
//
do {
a= ep;
ep= ep.getNext();
es.fRightLength++;
} while (ep != null && ep.isDelete() && ep.fRightStart == a.fRightStart + 1);
boolean change= (ep != null && ep.isInsert() && ep.fRightStart == a.fRightStart);
if (change) {
RangeDifference b= ep;
//
// replacement lines
//
do {
ep= ep.getNext();
es.fLeftLength++;
} while (ep != null && ep.isInsert() && ep.fRightStart == b.fRightStart);
} else {
es.fLeftLength= 0;
}
es.fLeftStart++; // meaning of range changes from "insert after", to "replace with"
}
//
// the script commands are 1 based, subtract one to make them zero based
//
es.fRightStart--;
es.fLeftStart--;
result.add(es);
}
return (RangeDifference[]) result.toArray(EMPTY_RESULT);
}
/*
* Tests if two ranges are equal
*/
private static boolean rangesEqual(IRangeComparator a, int ai, IRangeComparator b, int bi) {
return a.rangesEqual(ai, b, bi);
}
/*
* Tests whether <code>right</code> and <code>left</code> changed in the same way
*/
private static boolean rangeSpansEqual(IRangeComparator right, int rightStart, int rightLen, IRangeComparator left, int leftStart, int leftLen) {
if (rightLen == leftLen) {
int i= 0;
for (i= 0; i < rightLen; i++) {
if (!rangesEqual(right, rightStart + i, left, leftStart + i))
break;
}
if (i == rightLen)
return true;
}
return false;
}
/*
* Reverses the range differences
*/
private static LinkedRangeDifference reverseDifferences(LinkedRangeDifference start) {
LinkedRangeDifference ep, behind, ahead;
ahead= start;
ep= null;
while (ahead != null) {
behind= ep;
ep= ahead;
ahead= ahead.getNext();
ep.setNext(behind);
}
return ep;
}
}
下面是一段關於如何使用這些類的簡單的測試代碼
public class RangeDifferencerTest extends TestCase {
InputStream left = null;
InputStream right = null;
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception {
String file1 = "d:/temp/1.txt";
String file2 = "d:/temp/2.txt";
left = new FileInputStream(new File(file1));
right = new FileInputStream(new File(file2));
super.setUp();
}
/**
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception {
left.close();
right.close();
super.tearDown();
}
public static void main(String[] args) {
}
/*
* Test method for 'com.greatroad.smbnm.compare.RangeDifferencer.findDifferences(IRangeComparator, IRangeComparator)'
*/
public void testFindDifferences() {
try {
RangeDifference[] rds = RangeDifferencer.findRanges(new LineComparator(left,"GBK"),new LineComparator(right,"GBK"));
if(rds != null ){
for(int i=0; i<rds.length; i++){
RangeDifference rd = rds[i];
int length = rd.leftLength();
System.out.println(
"kind = "+rd.kind()
+",left["+rd.leftStart()+"-"+rd.leftEnd()
+"],right["+rd.rightStart()+"-"+rd.rightEnd()+"]");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
5. 文本分類的演算法是屬於機器學習么
經過演算法不斷自己調優就可以算機器學習，簡單理解就是演算法來進行分類而且效果很好
如果有標簽屬於監督學習，沒有標簽屬於無監督學習
6. k-means聚類演算法的java代碼實現文本聚類
K-MEANS演算法:
k-means 演算法接受輸入量 k ；然後將n個數據對象劃分為 k個聚類以便使得所獲得的聚類滿足：同一聚類中的對象相似度較高；而不同聚類中的對象相似度較小。聚類相似度是利用各聚類中對象的均值所獲得一個「中心對象」（引力中心）來進行計算的。
k-means 演算法的工作過程說明如下：首先從n個數據對象任意選擇 k 個對象作為初始聚類中心；而對於所剩下其它對象，則根據它們與這些聚類中心的相似度（距離），分別將它們分配給與其最相似的（聚類中心所代表的）聚類；然後再計算每個所獲新聚類的聚類中心（該聚類中所有對象的均值）；不斷重復這一過程直到標准測度函數開始收斂為止。一般都採用均方差作為標准測度函數. k個聚類具有以下特點：各聚類本身盡可能的緊湊，而各聚類之間盡可能的分開。
具體如下：
輸入：k, data[n];
（1） 選擇k個初始中心點，例如c[0]=data[0],…c[k-1]=data[k-1];
（2） 對於data[0]….data[n], 分別與c[0]…c[n-1]比較，假定與c[i]差值最少，就標記為i;
（3） 對於所有標記為i點，重新計算c[i]=/標記為i的個數；
（4） 重復(2)(3),直到所有c[i]值的變化小於給定閾值。
演算法實現起來應該很容易，就不幫你編寫代碼了。
7. 誰懂文本滑動演算法
5日滑動平均演算法，具體一些
8. 求一段加密後的文本內容的原文及採用的加密演算法
兩次MD5加密後的組合。
例：原參數為id=100&pid=200
加密方法：先將前面的「100」加密，再將後面的200加密，兩個參數的加密字元要寫進資料庫，然後兩段代碼組合成64位。
程序讀取到這么長的代碼後，用函數把代碼分解，分別去匹配庫里的加密字元串，便可以得到相應的數據（ID，PID）。
你想解密的話，還是算了吧，加5000分也沒人能解出來。
9. knn演算法用來文本分類怎麼樣
一般
10. 目前最好的文本分類演算法
文本分類問題與其它分類問題沒有本質上的區別，其方法可以歸結為根據待分類數據的某些特徵來進行匹配，當然完全的匹配是不太可能的，因此必須（根據某種評價標准）選擇最優的匹配結果，從而完成分類。