import Python
PythonLibrary.useVersion(3, 6)

let np = Python.import("numpy")

let a = np.array([[1, 0], [0, 1]])
let b = np.array([[2], [3]])
let c = np.matmul(a, b)

import Foundation
import TensorFlow

struct XOR: Layer {
  
  var layer1: Dense<Float>
  var layer2: Dense<Float>
  
  init(hiddenSize:Int = 2){
    self.layer1 = Dense(inputSize: 2,
                        outputSize: hiddenSize,
                        activation: sigmoid)
    self.layer2 = Dense(inputSize: hiddenSize,
                        outputSize: 1, 
                        activation: sigmoid)
  }
  
  @differentiable
  func applied(to input: Tensor<Float>, in context: Context) -> Tensor<Float> {
    return input.sequenced(in: context, through: layer1, layer2)
    }
}

let x: Tensor<Float> = [[0, 0], [0, 1], [1, 0], [1, 1]]
let y: Tensor<Float> = [[0], [1], [1], [0]]

var model = XOR()
let optimizer = SGD<XOR, Float>(learningRate: 0.1)
let context = Context(learningPhase: .training)

for _ in 1...5000 {
  let dmodel = model.gradient { m -> Tensor<Float> in
    let t = m.applied(to: x, in: context)
    let loss = sigmoidCrossEntropy(logits: t, labels: y)
    return loss
  }
  optimizer.update(&model.allDifferentiableVariables, along: dmodel)
}

let inference = round(model.inferring(from: x))
print(inference)

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix
from sklearn.externals import joblib

def train_random_forest(x_train, y_train, save_name: str):

    # RFの定義
    forest = RandomForestClassifier(n_estimators=100, n_jobs=-1)

    # 学習
    forest.fit(x_train, y_train)

    # 保存
    joblib.dump(forest, save_name, compress=True)

    return forest

def test_random_forest(x_test, y_test, model_name: str):

    # RFの読み込み
    forest = joblib.load(model_name)

    # 予測データの作成
    y_predict = forest.predict(x_test)
    y_proba = forest.predict_proba(x_test)

    # 正解率
    acc_score = accuracy_score(y_test, y_predict)
    print("acc: {}".format(acc_score))

    # F値と混同行列
    f1_sc = f1_score(y_test, y_predict)
    conf_mat = confusion_matrix(y_test, y_predict)
    print('f1 score: {}'.format(f1_sc))
    print('Confusion matrix: {}'.format(conf_mat))

    # 特徴量の重要度
    # 特徴量名があればさらに見やすい結果になります
    # ここで定義した特徴量名は適当です
    feature_names = ["feature0", "feature1", "feature2"]
    importances = forest.feature_importances_
    for (f, i) in zip(feature_names, importances):
        print("{}, {}".format(f, i))

forest = RandomForestClassifier(class_weight="balanced")

from imblearn.ensemble import BalancedBaggingClassifier
forest = BalancedBaggingClassifier(n_estimators=100,n_jobs=-1)

$ export PYTHONPATH="hogehoge/mylib"

import sys
for path in sys.path:
  print(path)

/Users/user/.pyenv/versions/3.6.1/lib/python3.6/site-packages

pth_file = "mylib.pth"
pth_body = "hogehoge/mylib"
for path in sys.path:
  if ".pyenv" in path and path.endswith("site-packages") is True:
    save_path = os.path.join(path, pth_file)
    with open(save_path, "w") as f:
      f.write(pth_body)

# $ python add_pth_file.py delete
if len(args) > 1 and args[1] == "delete":
  if os.path.exists(save_path):
    os.remove(save_path)

from numpy.random import rand
vec_list = []
for base in [[10, 10], [0, 0]]:
  for _ in range(100):
    temp = [base[0] + rand(), base[1] + rand()]
    vec_list.append(temp)

import numpy as np
nvec = np.array(vec_list)

from sklearn.mixture import BayesianGaussianMixture
gmm = BayesianGaussianMixture(n_components=10, verbose=1, max_iter=1000)
gmm.fit(nvec)

clusters = gmm.predict(nvec)
print("clusters:", clusters)

'''
clusters: [5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]
'''

clusters_set = set(clusters)
print("clusters_set:", clusters_set)
print("len(clusters_set):", len(clusters_set))
'''
clusters_set: {2, 5}
len(clusters_set): 2
'''

weights = gmm.weights_
components = gmm.n_components
x_clusters = np.arange(components)
plt.bar(x_clusters, weights, tick_label=x_clusters)
plt.show

corpus_vec_list = []
for corpus in corpus_data:
  temp_vec = [0 for i in range(topic_count)]
  for tp in lda.get_document_topics(corpus):
    temp_vec[tp[0]] = tp[1]
  corpus_vec_list.append(temp_vec)

def calc_gmm(vec_list, component):
	from sklearn.mixture import GaussianMixture
	gmm = GaussianMixture(n_components=component, covariance_type='full')
	
	import numpy as np
	nvec = np.array(vec_list)
	
	gmm.fit(nvec)
	clusters = gmm.predict(nvec)
	proba = gmm.predict_proba(nvec)
	bic = gmm.bic(nvec)
	return clusters, proba, bic

import sys
min_bic = sys.float_info.max
best_component = 0
        
for component in range(20, 30):
	clusters, proba, bic = calc_gmm(corpus_vec_list, component)
	if bic < min_bic:
		min_bic = bic
		best_component = component

docments = [["分かち書き", "された", "文章1"], ... ]
categories = ["文章1のカテゴリー", ...]

from gensim import corpora
from gensim import models
from sklearn.model_selection import train_test_split

dictionary = corpora.Dictionary(documents)

# ストップワード
ignores = []
ignored_words_file = "./stop_words.txt"
with open(ignored_words_file, "r", encoding="utf-8") as f:
    ignores = [line.replace(os.linesep, "") for line in f]

# フィルタリング
dictionary.filter_extremes(no_below=20, no_above=0.5, keep_n=100000)
stop_ids = [dictionary.token2id[ig] for ig in ignores if ig in dictionary.token2id]
dictionary.filter_tokens(stop_ids)
dictionary.compactify()

corpus = [dictionary.doc2bow(text) for text in documents]
x_train, x_test, y_train, y_test = train_test_split(corpus, categories, test_size=0.1, random_state=1)
    
lda = models.LdaModel(corpus=x_train, id2word=dictionary, num_topics=9, iterations=50, passes=20)

def calc_perplexity(m, c):
    import numpy as np
    return np.exp(-m.log_perplexity(c))

# パープレキシティ
p = calc_perplexity(lda, x_test)

# 上位語彙
each_topics = []
for i in range(lda.num_topics):
    words = lda.show_topic(i, topn=topic_count)
    each_topics += [[w[0] for w in words]]

# 分類
for x in x_test:
    topics = lda.get_document_topics(x)
    top_topic = sorted(topics, key=lambda topic: topic[1], reverse=True)[0][0]

# 推定トピック数の最大値はデフォルトで150に設定されている
hdp = models.hdpmodel.HdpModel(corpus, id2word=dictionary, alpha=0.1)

def topic_prob_extractor(hdp, save_csv_file=None):
    import pandas as pd
    shown_topics = hdp.show_topics(num_topics=-1, formatted=False)
    topics_nos = [x[0] for x in shown_topics]
    weights = [sum([item[1] for item in shown_topics[topicN][1]]) for topicN in topics_nos]
    data_frame = pd.DataFrame({'topic_id': topics_nos, 'weight': weights})
    if save_csv_file is not None:
        data_frame.to_csv(save_csv_file)
    return data_frame

$ git clone https://github.com/facebookresearch/fastText.git
$ cd fastText
$ pip install .