README.md

moodstyle机器学习脚本库

machine learning algorithm with pure python which let pramgramer learn easily;

please push your code to this project,let's learn together;

• AdBoost.py
  • BoostClassifier(object)
    • init(self, classifier, weight=None)
    • call(self, data)
    • str(self)
  • BoostData(object)
    • init(self, data, weight=None)
  • AdBoost(object)
    • init(self, classifiers=[])
    • train(self, datas)
    • classify(self, data)
    • __update_data_weight(self, trains, classifier)
    • str(self)
    • __get_trainer(self, trains)
• AdTree.py
  • Classifier(object)
    • init(self, classifier)
    • clear(self)
    • update_fit_value(self, data, value)
    • updates_fit_values(self, datas, values)
    • sync(self)
    • classify(self, data)
    • str(self)
  • AdTree(object)
    • init(self)
    • train(self, datas, weights, classifiers, diff=0.2)
    • find_min_loss(self, datas, residuals, classifiers)
    • update_residual(self, datas, residuals , classifier)
    • classify(self, data)
• Ann.py
  • Ann(testInterface.Classify)
    • init(self , w , learn_rate = 0.1 , labels = [1 , -1 ])
    • __train(self , data , label)
    • classify(self , data , *argv , **kw )
    • train(self , datas , labels , *argv , **kw)
• Array.py
  • PoolArray(objects)
    • init(self , objects , sample_rate )
    • create_rand_list(self)
    • next(self)
  • WaterSample(object)
    • init(self , objects , sample_rate)
    • get_rand_score(self )
    • next(self)
  • SampleArray(object)
    • init(self , objects , sample_ + = WaterSample)
    • iter(self)
    • getitem(self , index )
• Bandit.py
  • Greedy(object)
    • init(self,e,N)
    • _prop(self)
    • getIndex(self)
    • process(self,label)
  • UCB(object)
    • init(self,N,max_value)
    • _prop(self)
    • getIndex(self)
    • process(self,label)
• BaseStrut.py
  • WeightArray(object)
    • init(self, datas, distance_fun)
    • getitem(self, label_tuple)
    • get_distance_by_index(self , row , line )
    • create_distance_map(self, datas, distance_fun)
  • Normalization(object)
    • init(self, *argv , **kw)
    • update(self , value)
    • get_normalization(self ,value )
  • MinMax(Normalization)
    • init(self , max_value = None , min_value = None )
    • update(self , value)
    • get_normalization(self , value )
  • ZScore(Normalization)
    • init(self)
    • update(self , values)
    • get_normalization(self , value)
  • LogNormalization(Normalization)
    • init(self , base = 10 )
    • get_normalization(self , value )
  • Arccotx(Normalization)
    • get_normalization(self , value )
• Bayes.py
  • Bayes(object)
    • train(self, datas, attr_len, labels, dense=True)
    • _predict(self , data , label)
    • get_prob(self , attr_index , value ,label )
    • predict(self, data)
    • predict_old(self, data)
• Bp.py
  • Layer(object)
    • init(self , layer_count , default = 1.)
    • len(self)
  • RatioArray(object)
    • init(self, line , row , min_value , max_value )
  • Bp(object)
  • rand(a, b)
  • makeMatrix(I, J, fill=0.0)
  • sigmoid(x)
  • dsigmoid(y)
  • NN
    • init(self, ni, nh, no)
    • update(self, inputs)
    • backPropagate(self, targets, N, M)
    • test(self, patterns)
    • weights(self)
    • train(self, patterns, iterations=1000, N=0.5, M=0.1)
  • demo()
• Bp1.py
  • Neroun(object)
    • init(self , weight_len , learn_rate = 0.1 , delta = random.uniform(1 , -1))
    • init_weights(self , weight_len , weight_max = 0.5 , weight_min = -0.5)
    • predict(self , inputs)
    • simgod(self , value)
    • disgod(self , target)
    • len(self)
    • getitem(self , index)
    • setitem(self , index , value)
    • update(self , target, predict)
  • Layer(object)
    • init(self , inputs_len ,neroun_len , learn_rate = 0.1)
    • predict(self , inputs )
    • train_predict(self , inputs)
    • update(self , deltas)
    • get_delta(self ,errors)
  • OutPutLayer(Layer)
    • get_delta(self , errors )
  • HiddenLayer(Layer)
    • init(self , inputs_len ,neroun_len , next_layer, learn_rate = 0.1)
    • get_delta(self , errors )
  • Bp(object)
    • init(self , inputs_len , hidden_len , outputs_len)
    • predict(self , inputs)
    • _train_predict(self , inputs)
    • train(self , inputs ,targets )
• Canopy.py
  • Canopy(object)
    • init(self, centre)
    • str(self)
  • CanopyCluster(object)
    • init(self, t1, t2)
    • cluster(self, datas)
    • distance(self, data1, data2)
  • SimpleCanopyCluster(CanopyCluster)
    • distance(self, data1, data2)
• Cart.py
  • Node(object)
    • init(self, split_attr, split_value)
    • str(self)
  • CartTree(object)
    • init(self)
    • load_model(self, file_path)
    • save(self, model_path)
    • __train(self, datas, labels, attrs, threshold=0.01)
    • split_data_by_attr(self, datas, attrs, attr_name)
    • train(self, datas, attrs, labels, threshold=0.01)
    • get_split_attr(self, attrs, attr)
    • get_split_value(self, datas, split_index)
    • calc_gini(self, datas, labels, split_index, split_value)
    • get_best_feature(self, datas, labels, attrs)
    • _classify(self, data, attrs, node)
    • classify(self, data)
• DDistance.py
  • DDdistance(object)
    • distance(self, data1, data2)
  • Manhattan(DDdistance)
    • distance(self, data1, data2)
  • DefaultDistance(DDdistance)
    • distance(self, data1, data2)
  • Chebyshev(DDdistance)
    • distance(self, data1, data2)
  • Cosine(DDdistance)
    • distance(self, data1, data2)
  • Hamming(DDdistance)
    • distance(self, data1, data2)
  • Euclidean(DDdistance)
    • distance(self, data1, data2)
• DataSet.py
  • DList(list)
    • items(self)
    • has_key(self , value)
    • update(self , data)
    • keys(self)
    • order_key(self)
    • values(self)
  • DeseData(DList)
    • init(self , data , default_value , data_len , *argv , **kw)
    • len(self)
    • setitem(self , index , value )
  • SparseData(dict)
    • init(self ,data , default_value , data_len , *argv , **kw)
    • getitem(self , index )
    • setitem(self , index , value)
    • len(self)
    • order_key(self)
  • DataSet(DList)
    • init(self ,data_len, dense_data , *argv , **kw)
    • append(self , data = None)
    • extend(self , data)
    • shape(self)
    • data_range(self)
• DbScan.py
  • ClusterItem(object)
    • init(self , data)
  • DbScan(object)
    • cluster(self , datas , radius , minPoint)
    • distance(self , data1 , data2 )
• DecisionTree.py
  • Node(object)
    • init(self, attr_name=None, label=None)
    • str(self)
  • DecisionTree(object)
    • init(self)
    • train(self, datas, attrs, threshold=0.01, denseData=True, tree=None)
    • entropy(probs)
    • getSplitAttrs(self, attrs, attr)
    • getBestFeature(self, datas, attrs, denseData)
    • splitDataByAttr(self, datas, attrs, attr_name, attr_value, denseData=True)
    • classify(self, data)
• DecisionTree1.py
  • Node(dict)
  • DecisionTree(object)
    • init(self)
    • load_model(self, file_path)
    • save(self, model_path)
    • __train(self, datas , labels , attrs, threshold=0.01, dense_data=True)
    • train(self, datas , labels , attrs, threshold=0.01, dense_data=True)
    • entropy(probs)
    • get_split_attr(self, attrs, attr)
    • get_best_feature(self, datas, labels, attrs, dense_data)
    • split_data_by_attr(self, datas , labels , attrs, attr_name, attr_value, dense_data=True)
    • classify(self, data)
  • ID3(DecisionTree)
    • get_best_feature(self, datas , labels , attrs, dense_data)
  • C45(ID3)
    • get_best_feature(self, datas , labels, attrs, dense_data)
• DefaultValue.py
  • MissingValue(object)
    • get_value(self, feature)
  • ArvgMissingValue(object)
    • init(self, feature_len)
    • add(self, feature, value)
• Dict.py
  • Dictionary(dict)
    • init(self , **kw)
    • open_dict(self , dict_path)
    • setitem(self ,key, value)
    • to_vector(self , words)
    • to_one_hot(self , words)
• Emm.py
  • Emm(object)
    • init(self )
• Feature.py
  • Binning(object)
    • init(self,k,box = None)
    • train(self,features)
    • predict(self,feature)
    • _sort(self,array)
  • EqualRate(Binning)
    • train(self,features)
  • EqualLength(Binning)
    • train(self,features)
• FeatureExtract.py
  • Document(object)
    • init(self)
    • insert_document(self, doc_type, document= [])
    • get_word_count(self, word)
    • get_type_word_count(self, doc_type, word)
    • get_doc_count(self, doc_type)
    • get_word_set(self)
    • get_type_set(self)
    • str(self)
  • ITextFeatureScore(object)
    • feature_socre(self, doc_word_count, doc_count, word_count, doc_sum)
  • CreateDocument(object)
    • init(self)
    • insert_document_list(self, doc_name, contents, ngram=1, word_split=' ')
    • text_extract(self, words , ngram = 2, word_split = None)
  • TextFeature(object)
    • init(self, min_word_count=0, filter_rate=0.003)
    • extract_feature(self, doc, top_word=0.01)
    • text_feature_score(self, doc_word_count, doc_count, word_count, doc_sum)
    • filter(self, doc , doc_type , word)
  • IM(TextFeature)
    • text_feature_score(self, doc_word_count, doc_count, word_count, doc_sum)
  • CHI(TextFeature)
    • text_feature_score(self, doc_word_count, doc_count, word_count, doc_sum)
  • DF(TextFeature)
    • text_feature_score(self, doc_word_count, doc_count, word_count, doc_sum)
  • WLLR(TextFeature)
    • text_feature_score(self, doc_word_count, doc_count, word_count, doc_sum)
  • IG(TextFeature)
• GRTree.py
• HCluster.py
  • HierarchicalClustering(object)
    • init(self)
    • cluster(self, datas, cluster_num, threshold=0.03)
    • distance(self, data1, data2)
    • get_cluster_distance(self, cluster1, cluster2, distance_map)
  • ALHierarchicalClustering(HierarchicalClustering)
    • get_cluster_distance(self, cluster1, cluster2, distance_map)
  • SLHierarchicalClustering(HierarchicalClustering)
    • get_cluster_distance(self, cluster1, cluster2, distance_map)
  • CLHierarchicalClustering(HierarchicalClustering)
    • get_cluster_distance(self, cluster1, cluster2, distance_map)
• Hmm.py
  • HmmItem(object)
    • init(self, obs, hide)
    • str(self)
  • HmmItems(list)
    • __check(self, value)
    • setitem(self, key, value)
    • append(self, value)
    • str(self)
  • HmmModel(object)
    • init(self, states)
    • create_start_states(self, states, init_value=0.)
    • create_transition_probability(self, states, init_value=0.)
    • create_emission_probability(self, states)
  • Hmm(object)
    • init(self, model_path)
    • load(self, model_path)
    • viterbi(self, obs)
  • TrainHmm(object)
    • init(self, states)
    • save(self, model_path)
    • add_items(self, hmmitems)
    • translate(self)
  • TrainSeg(object)
    • init(self , states = ['s' , 'e' , 'm' ,'b'])
    • add_line(self , line)
    • word_state(self , word)
    • train()
• Hmm1.py
  • HmmItem(object)
    • init(self, obs, hide)
    • str(self)
  • HmmItems(list)
    • __check(self, value)
    • setitem(self, key, value)
    • append(self, value)
    • str(self)
  • HmmModel(object)
    • init(self, states)
    • create_start_states(self, states, init_value=0.)
    • create_transition_probability(self, states, init_value=0.)
    • create_emission_probability(self, states)
  • Hmm(object)
    • init(self, model_path)
    • load(self, model_path)
    • viterbi(self, obs)
  • TrainHmm(object)
    • init(self, states)
    • save(self, model_path)
    • add_items(self, hmmitems)
    • translate(self)
  • TrainSeg(object)
    • init(self , states = ['s' , 'e' , 'm' ,'b'])
    • add_line(self , line)
    • word_state(self , word)
• Interface.py
  • Classify(object)
    • classify(self , data , *argv , **kw)
  • Regression(object)
    • predict(self , data , *argv , **kw)
• KdTree.py
• Kmeans.py
  • Center(object)
    • init(self, label, center_vector, distance_fun=None)
    • sub(self, value)
  • Kmeans(object)
    • cluster(self, datas, k, iter_count=10000, diff=0.00001)
    • rand_seed(self, datas, k)
    • update_centers(self, datas, labels, centers)
  • DKmeans(Kmeans)
    • distance(self, data1, data2)
  • ManhattanKmeans(Kmeans, Manhattan)
  • HammingKmeans(Kmeans, Hamming)
  • CosineKmeans(Kmeans, Cosine)
  • EuclideanKmeans(Kmeans, Euclidean)
• KmeansPlusPlus.py
  • KmeansPlusPlus(Kmeans)
    • rand_seed(self, datas, k)
  • DKmeansPlusPlus(KmeansPlusPlus , DKmeans)
• Knn.py
  • ClassItem(object)
  • KdNode(object)
    • init(self, split, left_child, right_child, data, parrent_node)
  • KdTree(object)
    • create_kd_tree(self, datas, k, feature_len, depth)
    • get_split_index(self, datas, k, feature_len, depth)
  • Knn(object)
    • init(self, train_data, labels, top_n)
    • classify(self, data)
• LinerModel.py
  • LinerModel(object)
    • train(self , datas , labels , item_len , learn_rate )
    • update_weight(self , l , target , data , learn_rate)
    • predict(self , data)
• Logistic.py
  • Logistic(object)
    • train(self, datas, labels, alpha=0.001)
    • classify(self, data)
    • sigmod(self, x)
• MiniBatchKMeans.py
  • MiniBatchKmeans(Kmeans)
    • cluster(self, datas, k, iter_count=10000, diff=0.00001)
    • rand_seed(self, datas, k)
    • add(self, center, data, eta, data_len)
  • DMiniBatchKmeans(MiniBatchKmeans, DefaultDistance)
• Ngram.py
  • ngram(content, splitor = " " , n = 2 )
• OneHotCode.py
  • OneHotCode(object)
    • init(self)
    • train(self,data)
    • predict(self,data)
• PageRank.py
  • Graph(object)
    • init(self , point_len , dense = True )
    • len(self)
    • add_edge(self , point_a , point_b)
    • keys(self)
    • ins(self , point)
    • outs(self , point)
    • outs_count(self , point)
    • update(self,weights)
  • GraphV2(object)
    • init(self,point_len)
    • len(self)
    • add_edge(self ,point_a , point_b)
    • keys(self)
    • outs_count(self,point)
    • update(self,weights)
    • ins(self,point)
  • PageRank(object)
    • rank(self , graph ,iter_count = 1000, d = 0.85 , min_error = 0.01)
    • calc_error(self , weights , graph)
• RandomForst.py
  • RF(object)
• RegressionTree.py
  • TreeNode(object)
    • init(self)
  • RegressionTree(object)
    • init(self)
    • train(self , datasets , targets)
    • loss(self , datasets , labels , attr , split_value)
    • get_target_avg(self , datasets ,targets , attr , split_value)
• init.py
• config.py
  • set_prefs(prefs)
  • project_opened(project)