The post 小学校から「将来の夢」についてお手紙をいただきました。 first appeared on ALBERT Official Blog.

はじめに

ロボットへの期待

強化学習とロボット

強化学習とは

強化学習の枠組み

探索と学習

強化学習の利点

強化学習の課題

QT-Opt: Scalable Deep Reinforcement Learning for Vision-Based Robotic Manipulation

論文の概要

論文の実験設定

QT-Optで学習したモデルの性能

オフライン経験データを用いたQT-Optの学習

オフライン経験データの内訳と性能への影響

実験

実験設計

• A: \pi_{scripted}による10,000回分の把持試行を行って集めた経験データセット
• B: \pi_{scripted}による100,000回分の把持試行を行って集めた経験データセット
• C: \pi_{scripted}による50,000回分の把持試行を行って集めた経験データセット + \pi_{eval}による30,000回分の把持試行を行って集めた経験データセット

結果

考察

まとめ

参考文献

1. D. Kalashnikov, A. Irpan, P. Pastor, J. Ibarz, A. Herzog, E. Jang, D. Quillen, E. Holly, M. Kalakrishnan, V. Vanhoucke, S. Levine. QT-Opt: Scalable Deep Reinforcement Learning for Vision-Based Robotic Manipulation. In Conference on Robot Learning, 2018.
2. S. Levine, P. Pastor, A. Krizhevsky, and D. Quillen. Learning hand-eye coordination for robotic grasping with large-scale data collection. In International Symposium on Experimental Robotics, 2016.
3. V. Mnih, K. Kavukcuoglu, D. Silver, A. Graves, I. Antonoglou, D. Wierstra, and M. Riedmiller. Playing atari with deep reinforcement learning. NeurIPS Deep Learning Workshop 2013, 2013.
4. D. Quillen, E. Jang, O. Nachum, C. Finn, J. Ibarz, and S. Levine. Deep Reinforcement Learning for Vision-Based Robotic Grasping: A Simulated Comparative Evaluation of Off-Policy Methods. In 2018 IEEE International Conference on Robotics and Automation, pp. 6284-6291, 2018.
5. https://github.com/google-research/google-research/tree/master/dql_grasping
6. https://github.com/google-research/google-research/issues/14#issuecomment-475109307
7. https://github.com/bulletphysics/bullet3/blob/master/examples/pybullet/gym/pybullet_envs/baselines/enjoy_kuka_diverse_object_grasping.py
8. Y. Lu, K. Hausman, Y. Chebotar, M. Yan, E. Jang, A. Herzog, T. Xiao, A. Irpan, M. Khansari, D. Kalashinikov, and S. Levine. AW-Opt: Learning Robotic Skills with Imitation and Reinforcement at Scale. In Conference on Robot Learning, 2021
9. S. Lee, Y. Seo, K. Lee, P. Abbeel, and J. Shin. Offline-to-Online Reinforcement Learning via Balanced Replay and Pessimistic Q-Ensemble, In Conference on Robot Learning, 2021

The post QT-Optの紹介とオフライン経験データに関する実験 first appeared on ALBERT Official Blog.

はじめに

1. 夜空をカメラで撮影し続けて流れ星を検出
2. 検出した流れ星に向かってレーザーを照射
3. 願い事を0/1の信号に変換し、それに合わせてレーザーを点滅させることで願い事を送信

レーザー光照射位置の動かし方

ARマーカーの追跡実験 〜ひとまず動かす〜

• 1秒あたりの動作回数が少なく、遅延も大きい
  • この装置を動かすためには、「撮影→ARマーカーとレーザー光の検出→モーターの操作」と複数の段階を踏む必要があります。そのため、1秒あたりに命令を出せる回数が少ないという問題があります(1秒間に5回ほど)。また、各段階の処理に時間がかかるため、撮影してからモーターを動かすまでの遅延が大きいという問題もあります。
• 各部品の位置を毎回調節しなければならない
  • 特にレーザーポインターや鏡の位置はレーザー光の照射位置に直接影響し、少しずれると目標地点に照射できなくなってしまいます。また、持ち運びにも大変不便です。将来的に屋外で使うことになった場合を考えると各部品を固定する必要があります。
• レーザー光を検出して用いている
  • この実験ではARマーカーとレーザー光の位置を検出していましたが、最終的にはレーザーは夜空に向かって照射する予定であるため、レーザー光を観測することはできません。また、レーザー光は撮影画像の明るい場所を選んでいるだけなので、実験する日の条件によりカメラの絞りやゲインを都度調節する必要があります。
    さらに、撮影した画像における距離と実空間の距離は1:1で対応していません。例えば、カメラからの距離などによっても1ピクセルあたりの実空間での長さは変わります(カメラに近いほど大きく写る)。そのため、撮影画像における距離(ピクセル)の差から鏡を動かすと正確な目的地に到達するまでに時間がかかります。レーザー光が大きく動く場合を確認してみると、目標位置に向かう際に揺れる様な動きを見せながら徐々に動きが止まる様子が確認できます。これは、実空間での距離ではなく画像内の距離からモーターを動かしていることが原因です。

ARマーカーの追跡実験 〜装置の改良〜

流れ星を追う実験

今後の展望

失敗談、大変だったこと

まとめと感想

参考

The post 流れ星に全自動で願いを送る装置を作る first appeared on ALBERT Official Blog.

初めに

論文の内容

収集したデータは、トレーニングとテストセットに80：20の割合で分割されました（すなわち、最初の8日間のデータをトレーニングに、最後の2日間のデータをテストに使用しました）。そして、分単位の心拍数予測に対して、複雑さを増す3つの異なるアーキテクチャ（AR、LSTM、ConvLSTM）のパフォーマンスを比較しました。

AR（自己回帰モデル）
次数{p}のARプロセスは、時刻{t}の時系列の値{X_t}を、その前の{p}個の実現値{X_{t-1}},{X_{t-2}},{...},{X_{t-p}}を用いて、以下の式に従ってモデル化します。

{X_t = \beta_0 + \sum_{i=1}^{p}\beta_i X_{t-i} + \varepsilon_t .}

{F_t = \sigma(W_F x_t + U_F h_{t-1} + b_F),}
{I_t = \sigma(W_I x_t + U_I h_{t-1} + b_I),}
{\tilde{C_t} = tanh(W_C x_t + U_C h_{t-1} + b_C),}
{O_t =\sigma(W_O x_t + U_O h_{t-1} + b_O),}
{C_t = F_t \circ C_{t-1} + I_t \circ \tilde{C_t},}
{h_t = O_t \circ tanh(C_t).}

{F_t = \sigma(W_F \ast x_t + U_F \ast h_{t-1} + V_F \circ C_{t-1} + b_F),}
{I_t = \sigma(W_I \ast x_t + U_I \ast h_{t-1} + V_I \circ C_{t-1} + b_I),}
{\tilde{C_t} = tanh(W_C \ast x_t + U_C \ast h_{t-1} + b_C),}
{O_t =\sigma(W_O \ast x_t + U_O \ast h_{t-1} + V_O \circ C_t + b_O),}
{C_t = F_t \circ C_{t-1} + I_t \circ \tilde{C_t},}
{h_t = O_t \circ tanh(C_t).}

{MAE =\frac{1}{n}\sum_{i=1}^{n}\left | \widehat{y_i} - y_i \right |,}
{RMSE =\sqrt{\frac{1}{n}\sum_{i=1}^{n}(\widehat{y_i} - y_i)^2.}}

考察

結論

最後に

参考文献

The post 「Heart Rate Modeling and Prediction Using Autoregressive Models and Deep Learning」の紹介 first appeared on ALBERT Official Blog.

教えたくなるほどよくわかる数学の基礎講座 | ニュートンプレス (newtonpress.co.jp)

From 0 to Infinity in 26 Centuries:
The Extraordinary Story of Maths by Chris Waring (goodreads.com)

The post 書籍紹介『教えたくなるほどよくわかる 数学の基礎講座』 first appeared on ALBERT Official Blog.

今年は12名の新入社員が入社しました。

Aチーム：上流の作業と下流の作業とのコミュニケーションによって、よりトランプタワーの品質が高まるのでは、と感じた。

Bチーム：一回目の立て方では負けてしまったため、二回目では改善のポイントを探り作戦を立てた。さらに効率よく建てるためのアイデアを実施することで、高くすることができた。

■コミュニケーション研修

共通概念を作り上げるためのディスカッション

◆さいごに

The post 2022年4月、ALBERTに12名の新入社員が入社しました。 first appeared on ALBERT Official Blog.

6月4日　仕事研究＆インターンシップWEB EXPO JAPAN【全国】

6月12日　仕事研究＆インターンシップEXPO　東京会場

The post マイナビ主催学生向けイベントのDXセミナーに登壇しました。 first appeared on ALBERT Official Blog.

ALBERTとARISE analytics

合同新卒研修の概要

研修の様子

全体総評

研修を終えた各社新卒メンバーのコメント

まとめ

【採用情報】

The post ALBERT × ARISE analytics、業界初の合同新卒研修を開催 first appeared on ALBERT Official Blog.

ALBERTは２つの発表と企業展示に参加

■人工知能学会全国大会とは

ALBERTの発表

ブースの様子

最後に

The post 2022年度 人工知能学会全国大会（第36回）参加報告 first appeared on ALBERT Official Blog.

• どのような仮説が立てられるか？
• どのようなデータがあればこの仮説を検証できるか？
  
  

The post 中央大学の「AI・データサイエンス総合」で講義を実施 first appeared on ALBERT Official Blog.

自己紹介

研修内容 

• オリエンテーション・社内各部署の業務内容説明 
• 技術研修 
  • UNIX・クラウド・Docker基礎 
  • Python基礎 
  • GitHub基礎 
  • コーディング作法 
  • 機械学習の基礎 
  • 教師あり学習 
  • 教師なし学習 
  • 時系列分析 
  • RDB基礎 
  • Spark基礎 
  • 自然言語処理入門 
• ビジネス研修 
  • ビジネスライティング研修 
  • プレゼンテーション入門 
  • 分析報告書の書き方 
  • ビジネスマナー研修 
• 分析演習(5月) 
  • 離反者予測演習：音楽ストリーミングサービスにおける離反会員の予測 
  • クライアント対応演習：メーカーの検査工程におけるAIシステムの導入 
• 分析演習(6月)
  • ARISE analytics様との合同研修 
    • AI分析プロジェクトの進め方 
    • 音声データの異常検知：水流音から異常音を検知  
  • 画像セグメンテーション：深層学習を用いた車載カメラの画像データの物体認識 
  • 信用リスク分析：クレジットカード利用者のデフォルトリスクの推定 
  • 顧客分析：商品購買データから商品軸・顧客軸による分析と施策提案 

4月と5月の研修 

技術研修 

• 先輩社員が講師として教える講義形式 
• 事前に講義を録画したものを視聴する VOD 形式 

ビジネス研修 

離反者予測演習 

クライアント対応演習 

6月の研修 

ARISE様との合同研修 

個人での分析演習 

• 同期や講師（先輩社員）の方と話す機会が多く、想像よりずっと楽しい研修だった。 
• 研修を通してさらに学びたくなった内容もあるので、業務の合間や自己研鑽の時間を使って理解を深めたい。 
• 分析演習中にこっそり残業した場合は減点する、という注意があり時間管理の厳格さに驚いた。 
• 日報やslackにて、同期のリアクションやつぶやきが見られて面白かった。 
• 終礼や週に１回オンラインのランチ会など、先輩アナリストと交流の場が好きだった。

最後に 

The post 2022年 新卒研修レポート first appeared on ALBERT Official Blog.

The post 2022年夏季データ分析実務インターンを実施しました。 first appeared on ALBERT Official Blog.

■内定式

– 内定者自己紹介

– 会社見学

■交流会

– カードゲーム

– ALBERTクイズ

■まとめ

The post 2023年度新卒社員内定式を実施しました。 first appeared on ALBERT Official Blog.

■こだわりが詰まったオープニングムービー

■第１部企画「これまでのALBERT～17年の軌跡～」

■第１部企画「プロジェクト紹介」

■第１部企画「ALBERT Award 2022」

■ALBERT DAY Slack LIVEチャネル内のコメント数ランキング発表！

■第２部企画　「出張 アルベルト越境ラジオ！」

■食事、ノベルティ＆ギフト

■社内アンケートより

• 誰かに認められ表彰されることは誇らしいと思います。今後のモチベーションにもつながりました。
  
  
• オープニング、エンディングで開催コンセプトを特に感じることができました。リモート中心で会社の一体感が欠けやすくなっている状況にぴったりなテーマだったと思います。
  
  
• 当日の進行も滞りなく進み、司会の方の明るさ・さわやかさや、動画編集、企画のすばらしさ、Slackの集計の素早さなどとても良かったです。特にあまり関わることのない方々の素顔や話が聞けたのがとてもよかったです。
  
  
• 内容が豊富かつ進行がスムーズで、あっという間に時間が過ぎました。音楽・映像・美術も素晴らしく、本当にイベントという感じで気分が上がりました。
  
  
• 圧巻でした。素敵な時間をありがとうございました！

■さいごに

The post オンライン全社イベント『ALBERT DAY 2022』を開催しました。 first appeared on ALBERT Official Blog.

1. Introduction 

2. myCobotの基本 

• ファームウェアの書き込み 
• 関節のキャリブレーション 
• Transponderの起動 

# mycobot_control_test.py
#!/usr/bin/env python
import time

from pymycobot.mycobot import MyCobot
from pymycobot.genre import Angle, Coord

if __name__ == "__main__":
port = "/dev/ttyUSB0"
mycobot = MyCobot(port, baudrate="115200", timeout=0.1, debug=False) # baudrate以降はデフォルト値

# 関節角の取得・操作
print("get angles")
print(" degrees: {}\n".format(mycobot.get_angles()))
time.sleep(0.5)

print("get radians")
print(" radians: {}\n".format(mycobot.get_radians()))
time.sleep(0.5)

print("send angles: [0, 0, 0, 0, -90, 0]")
mycobot.send_angles([0, 0, 0, 0, 0, 0], 80)
time.sleep(1.5)
mycobot.send_angles([0, 0, 0, 0, -90, 0], 80)
print(" Is moving: {}\n".format(mycobot.is_moving()))
time.sleep(1.5)

print("send radians: [0, 0, 0, 0, 1.57, 0]\n")
mycobot.send_radians([0, 0, 0, 0, 1.57, 0], 80)
time.sleep(1.5)

print("send angle to joint 4: -90\n")
mycobot.send_angle(Angle.J4.value, -90, 80)
time.sleep(1.5)

# 座標と先端の向きの取得・操作
print("get coordination")
print(" coordination {}\n".format(mycobot.get_coords()))
time.sleep(0.5)

print("send coordination: [50, 50, 300, 0, 0, 0] → [50, 50, 300, 90, 90, 0]\n")
coord_list = [50, 50, 300, 0, 0, 0]
mycobot.send_coords(coord_list, 70, 0)
time.sleep(3.0)
coord_list = [50, 50, 300, 90, 90, 0]
mycobot.send_coords(coord_list, 70, 0)
time.sleep(1.5)

# グリッパーが付いている場合
# print("open gripper")
# mycobot.set_gripper_state(0, 80)
# time.sleep(1.0)
# print("close gripper")
# mycobot.set_gripper_state(1, 80)
# time.sleep(1.0)

time.sleep(1.5)
print("release all servos")
mycobot.release_all_servos()

mycobot = MyCobot(port, baudrate="115200", timeout=0.1, debug=False)

mycobot_urdf_gazebo.urdf 
~~
　　
        
         
         
        
         
     
~~

3. RealSense D455の基本 

Header header # ヘッダー 
uint32 height # データ行数 
uint32 width # データ列数 
PointField[] fields # 1点のデータ構造 
bool    is_bigendian # ビッグエンディアンかどうか 
uint32  point_step   # 1点のバイト数（8bit数値の数） 
uint32  row_step     # 1行のデータ数（= width * point_step） 
uint8[] data         # 生データ(8bitのrow_step * height個のデータ配列) 
bool is_dense        # Trueなら無効なデータはない

# CMakeLists.txt
find_package(catkin REQUIRED COMPONENTS 
# rospyとsensor_msgsモジュールがimportできるように追加 
    rospy sensor_msgs 
) 
catkin_package( 
# ビルドパッケージの追加 
    sensor_msgs 
) 
# 実行ファイルのディレクトリにscriptsを追加 
catkin_install_python(PROGRAMS 
   DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}/scripts 
)

  <build>rospy</build> 
  <build>sensor_msgs</build>

# red_point_detection.py
#!/usr/bin/env python3 
import time, os, sys, signal, threading 
 
import numpy as np 
 
import rospy 
from sensor_msgs.msg import PointCloud2 
 
class RedPointsDetectionNode(object): 
    def __init__(self): 
        super(RedPointsDetectionNode, self).__init__() 
        self.data = PointCloud2() 
        self.point_step = 20 
        self.R_COL = 18 
        self.G_COL = 17 
        self.B_COL = 16 
        rospy.init_node("red_points_detection_node") 
        rospy.loginfo("red points detection start") 
 
    # Subscriber         
    def sub_pointcloud(self): 
        def callback(data): 
            self.sub_data = data 
        sub = rospy.Subscriber("camera/depth/color/points", PointCloud2, callback = callback) 
        rospy.spin() 
 
    # Publisher 
    def pub_red_pointcloud(self): 
        pub = rospy.Publisher("red_point_cloud", PointCloud2, queue_size = 1) 
        while not rospy.is_shutdown(): 
            pub_data = self.red_point_detection(self.sub_data) 
            pub.publish(pub_data) 
             
    def red_point_detection(sub_data): 
            red_point_data = sub_data 
            red_pointcloud = np.array([d for d in sub_data.data]).reshape(-1, self.point_step) 
            r_flags = red_pointcloud < 180 
            g_flags = red_pointcloud > 150 
            b_flags = red_pointcloud > 150 
            R_under_threshold_row = np.where(r_flags)[0][np.where(np.where(r_flags)[1]==self.R_COL)] 
            G_over_threshold_row = np.where(g_flags)[0][np.where(np.where(g_flags)[1]==self.G_COL)] 
            B_over_threshold_row = np.where(b_flags)[0][np.where(np.where(b_flags)[1]==self.B_COL)] 
            not_red_row = np.unique(np.concatenate([R_under_threshold_row, G_over_threshold_row, B_over_threshold_row])) 
 
            red_pointcloud = np.delete(red_pointcloud, not_red_row, axis=0).ravel().tolist() 
            red_point_data.width = int(len(red_pointcloud) / self.point_step) 
            red_point_data.height = 1 
            red_point_data.row_step = pub_pc2_data.width * self.point_step 
            red_point_data.data = red_pointcloud 
            rospy.loginfo("red pointcloud {}".format(int(len(red_pointcloud) / self.point_step))) 
            return red_point_data 
     
    # node start to subscribe and publish 
    def start_node(self): 
        sub_pointcloud = threading.Thread(target = self.sub_pointcloud) 
        pub_red_pointcloud = threading.Thread(target = self.pub_red_pointcloud) 
 
        sub_pointcloud.setDaemon(True) 
        sub_pointcloud.start() 
        pub_red_pointcloud.setDaemon(True) 
        pub_red_pointcloud.start() 
 
        sub_pointcloud.join() 
        pub_red_pointcloud.join() 
 
if __name__ == "__main__": 
    color_points_detector = ColorPointsDetectionNode() 
    color_points_detector.start_node() 
    pass

# object_position_search.py
#!/usr/bin/env python3 
import time, os, sys, signal, threading 
 
import numpy as np 
 
import rospy 
from sensor_msgs.msg import PointCloud2 
import sensor_msgs.point_cloud2 as pc2 
from geometry_msgs.msg import Point 
 
class ObjectPositionSearchNode(object): 
    def __init__(self): 
        super(ObjectPositionSearchNode, self).__init__() 
        rospy.init_node("object_position_search_node") 
        rospy.loginfo("object position search start") 
        self.object_position = Point() 
 
    # Subscriber         
    def sub_pointcloud(self): 
        def callback(data): 
            rospy.loginfo("subscribed pointcloud") 
            xyz_generator = pc2.read_points(data, field_names = ("x", "y", "z"), skip_nans=True) 
            xyz_list = [gen for gen in xyz_generator] 
            list_num = len(xyz_list) 
            x = np.array([xyz_list[i][0] for i in range(list_num) if (xyz_list[i][2] < 1.0 and xyz_list[i][2] > -1.0)]) 
            y = np.array([xyz_list[i][1] for i in range(list_num) if (xyz_list[i][2] < 1.0 and xyz_list[i][2] > -1.0)]) 
            z = np.array([xyz_list[i][2] for i in range(list_num) if (xyz_list[i][2] < 1.0 and xyz_list[i][2] > -1.0)]) 
             
            self.object_position.x = np.average(x) 
            self.object_position.y = np.average(y) 
            self.object_position.z = np.average(z) 
 
        sub = rospy.Subscriber("red_point_cloud", PointCloud2, callback = callback) 
        rospy.spin() 
     
    # Publisher 
    def pub_target_position(self): 
        pub = rospy.Publisher("object_position", Point, queue_size=1) 
        while not rospy.is_shutdown(): 
            rospy.loginfo("published object position: {:.5f}, {:.5f}, {:.5f}\n".format(self.object_position.x, self.object_position.y, self.object_position.z)) 
            pub.publish(self.object_position)         
    def start_node(self): 
        sub_pointcloud = threading.Thread(target = self.sub_pointcloud) 
        pub_target_position = threading.Thread(target = self.pub_target_position) 
 
        sub_pointcloud.setDaemon(True) 
        sub_pointcloud.start() 
        pub_target_position.setDaemon(True) 
        pub_target_position.start() 
 
        sub_pointcloud.join() 
        pub_target_position.join() 
 
if __name__ == "__main__": 
    object_position_searcher = ObjectPositionSearchNode() 
    object_position_searcher.start_node() 
    pass

4. ROSを使ってmyCobotとRealSense D455の連携 

// tf_broadcaster.cpp
#include <ros/ros.h> 
#include <geometry_msgs/TransformStamped.h> 
#include <tf2_ros/static_transform_broadcaster.h> 
#include <tf2_geometry_msgs/tf2_geometry_msgs.h> 
 
class TfBroadcaster 
{ 
public: 
    TfBroadcaster(); 
    ~TfBroadcaster(); 
// Broadcast 
    void BroadcastStaticTfFromCameraToMyCobot(); 
 
private: 
    ros::NodeHandle nh_; 
// TF Broadcaster 
    tf2_ros::StaticTransformBroadcaster static_tf_broadcaster_; 
// constant 
    double PI_ = 3.1419265; 
}; 
 
TfBroadcaster::TfBroadcaster(){} 
TfBroadcaster::~TfBroadcaster(){} 
 
void TfMyCobotBroadcaster::BroadcastStaticTfFromCameraToMyCobot() 
{ 
    geometry_msgs::TransformStamped transformStamped; 
    transformStamped.header.stamp = ros::Time::now(); 
    transformStamped.header.frame_id = "camera_color_frame"; // 親link 
    transformStamped.child_frame_id = "base_link"; // 子link 
　　// 平行移動 
    transformStamped.transform.translation.x = -0.3; 
    transformStamped.transform.translation.y = -0.3; 
    transformStamped.transform.translation.z = -0.3; 
    // 回転 
    tf2::Quaternion q; 
    q.setEuler(0, 0, 0); 
    transformStamped.transform.rotation.x = q.x(); 
    transformStamped.transform.rotation.y = q.y(); 
    transformStamped.transform.rotation.z = q.z(); 
    transformStamped.transform.rotation.w = q.w(); 
     
    static_tf_broadcaster_.sendTransform(transformStamped);     
} 
 
int main(int argc, char** argv) 
{ 
    ros::init(argc, argv, "tf_mycobot_broadcaster"); 
    TfMyCobotBroadcaster tf_mycobot_broadcaster; 
    tf_mycobot_broadcaster.BroadcastStaticTfFromCameraToMyCobot(); 
 
    ros::Rate loop_rate(10); 
    while(ros::ok()){ 
        ros::spinOnce(); 
        loop_rate.sleep(); 
    } 
    return 0; 
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.0.2) 
project(tf_broadcaster) 
find_package(catkin REQUIRED COMPONENTS 
  roscpp geometry_msgs tf2_geometry_msgs) 
catkin_package( CATKIN_DEPENDS geometry_msgs tf2_geometry_msgs) 
include_directories(${catkin_INCLUDE_DIRS}) 
add_executable(tf_mycobot_broadcaster src/tf_mycobot_broadcaster.cpp) 
target_link_libraries(tf_mycobot_broadcaster ${catkin_LIBRARIES})

<!-- package.xml -->
<?xml version="1.0"?> 
<package format="2"> 
  <name>tf_broadcaster</name> 
 
  <version>0.0.0</version> 
  <description>The transform broadcaster package</description> 
  <maintainer email="root@todo.todo">root</maintainer> 
  <license>TODO</license> 
 
  <buildtool_depend>catkin</buildtool_depend> 
  <depend>tf2_geometry_msgs</depend> 
  <depend>geometry_msgs</depend> 
</package>

1. マーカー座標の決定 
   • マーカー点群のサブスクライブ 
   • 点群を3つにクラスタリング（by k-means method） 

2. 原点と単位ベクトルの決定 
   • マーカー2, 3の中点を原点V_robot 
   • X, Yの単位ベクトルV_X, V_YをそれぞれV_robot→マーカー1, V_robot→マーカー2 
   • Zの単位ベクトルは外積でマーカーのある平面の法線ベクトル 

3. カメラ姿勢からロボット姿勢への回転をEuler角で作成
   • theta_1 = カメラの水平面に対する仰角 
   • theta_2 = カメラの正面方向の回転角 
   • theta_3 = カメラとロボットのそれぞれの正面方向とのなす角 

4. 原点をmyCobotの固定台の分(2.7cm)、V_Z方向に平行移動 

# mycobot_position_calibration.py
#!/usr/bin/env python3 
import time, os, sys, signal, threading 
 
import numpy as np 
 
import rospy 
from sensor_msgs.msg import PointCloud2 
from geometry_msgs.msg import Point 
import sensor_msgs.point_cloud2 as pc2 
 
class MyCobotPositionCalibrationNode(object): 
    def __init__(self): 
        super(MyCobotPositionCalibrationNode, self).__init__() 
        rospy.init_node("mycobot_position_calibration_node") 
        rospy.loginfo("mycobot position calibration start") 
 
    # Subscriber         
    def sub_pointcloud(self): 
        def callback(data): 
            self.data = data 
            rospy.loginfo("subscribed pointcloud") 
            xyz_generator = pc2.read_points(self.data, field_names = ("x", "y", "z"), skip_nans=True) 
            xyz_list = [xyz for xyz in xyz_generator if (abs(xyz[0]) < 0.8 and abs(xyz[1]) < 0.8 and abs(xyz[2]) < 0.8)] 
            xyz_array = np.array(xyz_list) 
 
            if len(xyz_list) > 3: 
                marker_centroids = self.kmeans(3, xyz_array) 
                rospy.loginfo("\n marker positions\n{}".format(marker_centroids)) 
                translation = self.cal_translation(marker_centroids) 
                rospy.loginfo("\n translation\n{}".format(translation)) 
                 
        sub = rospy.Subscriber("blue_point_cloud", PointCloud2, callback = callback) 
        rospy.spin() 
 
    # node start 
    def start_node(self): 
        sub_pointcloud = threading.Thread(target = self.sub_pointcloud) 
        sub_pointcloud.setDaemon(True) 
        sub_pointcloud.start() 
        sub_pointcloud.join() 
     
    # clustering method 
    def kmeans(self, k, X, max_iter=30): # k: cluster num, X: numpy array 
        data_size, n_features = X.shape 
        centroids = X[np.random.choice(data_size, k)] 
        new_centroids = np.zeros((k, n_features)) 
        cluster = np.zeros(data_size) 
        for epoch in range(max_iter): 
            for i in range(data_size): 
                distances = np.sum((centroids - X[i]) ** 2, axis=1) 
                cluster[i] = np.argsort(distances)[0] 
            for j in range(k): 
                new_centroids[j] = X[cluster==j].mean(axis=0) 
            if np.sum(new_centroids == centroids) == k: 
                break 
            centroids = new_centroids 
        max_norm = 0 
        min_norm = 0 
        sorted_centroids = [] 
        for centroid in centroids: 
            norm = centroid[2] 
            if norm > max_norm: 
                sorted_centroids.append(centroid) 
                max_norm = norm 
                if min_norm == 0: 
                    min_norm = sorted_centroids[0][2] 
            else: 
                if norm > min_norm and min_norm != 0: 
                    sorted_centroids.insert(1, centroid) 
                else: 
                    sorted_centroids.insert(0, centroid) 
                    min_norm = norm 
        sorted_centroids = np.array(sorted_centroids) 
 
        return sorted_centroids 
 
    # translation angles calculation 
    ## calculation 
    def cal_translation(self, marker_points): 
        # マーカー1, 2, 3の位置ベクトル 
        a_1, a_2, a_3 = marker_points 
        # カメラからロボットへのベクトル 
        V_robot = self.cal_robot_position_vector(a_2, a_3) 
        # ロボットのXYZ単位ベクトル 
        V_X = (a_2 - V_robot) / (np.linalg.norm(a_2 - V_robot)) 
        V_Y = (a_1 - V_robot) / (np.linalg.norm(a_1 - V_robot)) 
        V_Z = self.cal_normal_vector(marker_points) 
 
        # カメラの水平面に対する仰角 
        theta_1 = - (np.pi/2 - self.cal_subtended_angle(-V_robot, V_Z)) 
        # カメラの正面方向の回転角 
        V_Y_camera = np.array([0, 1, 0]) 
        V_Y_camera_rotated = self.cal_rotate_vector_xaxis(V_Y_camera, -theta_1) 
        theta_2 = - self.cal_subtended_angle(V_Z, -V_Y_camera_rotated) 
        # カメラとロボットのそれぞれの正面方向とのなす角 
        _, V_robot_projected_to_plane = self.cal_vector_projection(V_robot, V_Z) 
        theta_3 = self.cal_subtended_angle(V_Y, V_robot_projected_to_plane) 
        # mycobotの位置を土台の高さ0.027 m, V_Z方向に平行移動 
        V_robot = V_robot + 0.027*V_Z 
 
        return V_robot, theta_1, theta_2, theta_3 
 
 
    ## vector and angle caluculation 
    def cal_robot_position_vector(self, a_2, a_3): 
        return (a_2 + a_3) / 2 
 
    def cal_normal_vector(self, marker_points): 
        a_1 = marker_points[0] 
        a_2 = marker_points[1] 
        a_3 = marker_points[2] 
        A_12 = a_2 - a_1 
        A_13 = a_3 - a_1 
        cross = np.cross(A_13, A_12) 
        return cross / np.linalg.norm(cross) 
 
    def cal_subtended_angle(self, vec_1, vec_2): 
        dot = np.dot(vec_1, vec_2) 
        norm_1 = np.linalg.norm(vec_1) 
        norm_2 = np.linalg.norm(vec_2) 
        return np.arccos( dot / (norm_1 * norm_2) ) 
     
    def cal_vector_projection(self, org_vec, normal_vec): 
        # org_vec: 射影したいベクトル 
        # normal_vec: 射影したい平面の法線ベクトル 
        projected_to_vertical = np.dot(org_vec, normal_vec) * normal_vec 
        projected_to_horizontal = org_vec + projected_to_vertical 
        return projected_to_vertical, projected_to_horizontal 
 
    def cal_rotate_vector_xaxis(self, vec, angle): 
        rotate_mat = np.array([[1, 0, 0], [0, np.cos(angle), np.sin(angle)], [0, -np.sin(angle), np.cos(angle)]]) 
        return vec.dot(rotate_mat) 
 
    def cal_rotate_vector_yaxis(self, vec, angle): 
        rotate_mat = np.array([[np.cos(angle), 0, -np.sin(angle)], [0, 1, 0], [np.sin(angle), 0, np.cos(angle)]]) 
        return vec.dot(rotate_mat) 
 
    def cal_rotate_vector_zaxis(self, vec, angle): 
        rotate_mat = np.array([[np.cos(angle), np.sin(angle), 0], [-np.sin(angle), np.cos(angle), 0], [0, 0, 1]]) 
        return vec.dot(rotate_mat) 
 
if __name__ == "__main__": 
    mycobot_position_calibrator = MyCobotPositionCalibrationNode() 
    mycobot_position_calibrator.start_node() 
 
    pass

// tf_broadcaster.cpp
~~ 
# それぞれ t_x,y,z と theta_1,_2,_3 に得られた値を入れる 
    transformStamped.transform.translation.x = t_z; 
    transformStamped.transform.translation.y = -t_x; 
    transformStamped.transform.translation.z = -t_y; 
     
    tf2::Quaternion q; 
    q.setEuler(theta_1, theta_2, theta_3); 
~~

# mycobot_reaching.py
#!/usr/bin/env python3 
import time, os, sys 
 
import numpy as np 
import quaternion 
from pymycobot.mycobot import MyCobot 
 
import rospy 
from geometry_msgs.msg import Point 
from tf.transformations import quaternion_from_euler 
 
class MyCobotReachingNode(object): 
    def __init__(self): 
        super(MyCobotReachingNode, self).__init__() 
        rospy.init_node("mycobot_reaching_node") 
        rospy.loginfo("mycobot reaching start") 
 
        # メンバ変数 
        # mycobot インスタンス 
        port = "/dev/ttyUSB0" 
        self.mycobot = MyCobot(port, baudrate="115200", timeout=0.1, debug=False) 
        # 平行移動と回転 
        # 光学座標系→mycoboto座標系なので4.2節とXYZ軸が違うことに注意 
        self.translation_from_camera_to_mycobot = np.array([t_x, t_y, t_z]) 
        q = quaternion_from_euler(-theta_2, -theta_3, theta_1) 
        self.rotation_from_camera_to_mycobot = quaternion.as_quat_array(q) 
        # subscriber 
        self.sub_point() 
 
    # Subscriber         
    def sub_point(self): 
        def callback(data): 
            rospy.loginfo("subscribed target point") 
            self.mycobot_move(data) 
 
        sub = rospy.Subscriber("object_position", Point, callback = callback) 
        rospy.spin() 
 
    # move mycobot 
    def mycobot_move(self, point_data): 
        # mycobot座標系への変換 
        target_point = np.array([point_data.x, point_data.y, point_data.z]) 
        target_point -= self.translation_from_camera_to_mycobot 
        target_point = quaternion.rotate_vectors(self.rotation_from_camera_to_mycobot, target_point) 
 
        # mm単位のため*1000、手前中心付近にリーチングするためx-20mm, z+40mm 
        coord_list = [target_point[0]*1000-20, -target_point[2]*1000, target_point[1]*1000+40, 0, 90, 0] 
        self.mycobot.send_coords(coord_list, 70, 0) 
        time.sleep(1.5) 
 
if __name__ == "__main__": 
    reaching = MyCobotReachingNode() 
    pass

<!-- mycobot_reaching.launch -->
<launch> 
    <include file="$(find mycobot_moveit)/launch/mycobot_moveit_control.launch" /> 
    <include file="$(find realsense2_camera)/launch/rs_camera.launch"> 
        <arg name="filters" value="pointcloud"/> 
    </include> 
 
    <node name="tf_broadcaster" pkg="tf_broadcaster" type="tf_broadcaster" /> 
 
    <node name="color_points_detectior" pkg="mycobot_test" type="red_points_detection.py" output="screen" /> 
    <node name="object_position_searcher" pkg="mycobot_test" type="object_position_search.py" output="screen" /> 
    <node name="mycobot_reaching_node" pkg="mycobot_test" type="mycobot_reaching.py" /> 
</launch>

# CMakeLists.txt
~~
# launchディレクトリの追加 
install(FILES 
  DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}/launch 
) 
~~

5. まとめ 

The post RealSense D455による空間認識でmyCobotを操作 first appeared on ALBERT Official Blog.

The post 中学生の企業訪問でリサーチャーとの意見交換を行いました。 first appeared on ALBERT Official Blog.

なぜ多くの評価指標が必要なのか

• 動画の各フレームに対して物体を検出
• 異なるフレームに存在する同じ物体同士を紐付け、同じIDを割り当てる

• 同一物体へのID割り当てに間違いは多いが、全ての物体を検出できている
• 一時的に検出されないタイミングがあるが、検出された際のID割り当ては完璧である

それでも単一の指標が欲しい

• 既存の評価指標の問題点を指摘した上で、
• 「物体の検出」「IDの割り当て」に特化した指標（DetA, AssA）を設計し、
• さらにそれらを統合した、たった1つの指標（HOTA）を提案する

既存の評価指標  

共通する用語  

IoU（Intersection over Union）  

trajectory（軌跡）  

MOTA（CLEAR MOT）[4]  

\displaystyle \begin{aligned} \textrm{MOTA} &= \textrm{1}−\frac{\textrm{|FN|}+\textrm{|FP|}+\textrm{|IDSW|}}{\textrm{|TP|}+\textrm{|FN|}} \\ &= \textrm{1}−\frac{\textrm{|FN|}+\textrm{|FP|}+\textrm{|IDSW|}}{\textrm{|gt|}} \end{aligned}

※より厳密に表現すると、「正解BBOXの予測ID」をそれと重なった予測BBOXのIDとするとき、各正解trajectoryを構成する正解BBOXの内で予測IDを持つものを時系列順に見ていき、予測IDが切り替わった回数となります。

※ちなみに上の議論では「IDSWが小さいのは現代trackerのID割り当て性能が非常に高いため」という可能性を排除できていません。しかしIDSWは「IDが切り替わった回数そのもの」であるのに対し、FN, FPは「ミスが起こった回数×そのミスが継続しているフレーム数」のような値となっており、本来同列に扱うべき量ではないというのが個人的な見解です。

※さらにFPがFNより小さいのは、追跡対象が人間という特徴的な形をしているものであり誤検出（FP）が比較的発生しにくいこと、一方で人間同士が重なることによる見逃し（FN）は容易に発生しうることが原因だと思われます。HOTA論文には「MOTAではFNとFPが対称ではないために、MOTAに合わせてチューニングするとFPが小さくなりがちである」という興味深い主張がありますが、OC-SORTではHOTAも評価指標として用いているためそれは根拠にはなりません。

IDF1（IDentification scores）[5]  

\displaystyle \textrm{IDF1}=\frac{\textrm{2|IDTP|}}{\textrm{2|IDTP|}+\textrm{|IDFN|}+\textrm{|IDFP|}}

※正解trajectoryと予測trajectoryマッチングはIDTPを最大化するように行われます。つまり「いつ、どこにいるか」の精度が最も高くなるように「誰」を選ぶ（=IDを割り当てる）というのがより正確な表現となります。

※ちなみに上で述べていることはあくまで評価指標の特性の話であり、ユースケースによっては単調性の有無が問題にならない場合もあります。例えば多少の見逃しを許容してでも誤った検出を行いたくない場合にはIDF1は適していることが考えられます。

新進気鋭の評価指標：HOTA[1, 2]  

「物体の検出」に関する評価指標：DetA  

\displaystyle \textrm{DetA}_\alpha = \frac{\textrm{|TP}_\alpha\textrm{|}}{\textrm{|TP}_\alpha\textrm{|}+\textrm{|FN}_\alpha\textrm{|}+\textrm{|FP}_\alpha\textrm{|}}

「IDの割り当て」に関する評価指標：AssA  

\displaystyle \begin{aligned} \textrm{AssA}_\alpha &= \frac{\textrm{1}}{\textrm{|TP}_\alpha\textrm{|}}\sum_{c \in \textrm{TP}_\alpha} \mathcal{A}_\alpha(c) \\ {\rm ただし} \mathcal{A}_\alpha(c) &= \frac{\textrm{|TPA}_\alpha\textrm{(c)|}}{\textrm{|TPA}_\alpha\textrm{(c)|}+\textrm{|FNA}_\alpha\textrm{(c)|}+\textrm{|FPA}_\alpha\textrm{(c)|}} \end{aligned}

※実は\mathcal{A}(c)やその構成要素は全て、cを含む正解trajectory1つと予測trajectory1つに対してのみ集計されるローカルなものです。従ってデータセット全体に対する指標であるAssAを得るためには何らかの手法で\mathcal{A}(c)を集約する必要があります。AssAではTPに関する平均が採用されていますが、その理由は次節で紹介します（一言で言うと、HOTA全体の単調性を担保するため）。

HOTAの算出方法  

\displaystyle \begin{aligned} \textrm{HOTA}_\alpha &= \sqrt{ \textrm{DetA}_\alpha \cdot \textrm{AssA}_\alpha} \\ &= \sqrt{ \frac{\textrm{|TP}_\alpha\textrm{|}}{\textrm{|TP}_\alpha\textrm{|}+\textrm{|FN}_\alpha\textrm{|}+\textrm{|FP}_\alpha\textrm{|}} \cdot \frac{\textrm{1}}{\textrm{|TP}_\alpha\textrm{|}} \sum_{c \in \textrm{TP}\alpha} \mathcal{A}_\alpha(c)} \\ &= \sqrt{ \frac{\sum_{c \in \textrm{TP}_\alpha} \mathcal{A}_\alpha(c)}{\textrm{|TP}_\alpha\textrm{|}+\textrm{|FN}_\alpha\textrm{|}+\textrm{|FP}_\alpha\textrm{|}}} \end{aligned}

\displaystyle \begin{aligned} \textrm{HOTA} &= \int_\textrm{0}^\textrm{1} \textrm{HOTA}_\alpha d \alpha \\ &\approx \frac{\textrm{1}}{\textrm{19}} \sum_{\alpha \in \left\{ \ \substack{\textrm{0.05, 0.10,} \\ \textrm{…, 0.95}} \ \right\} } \textrm{HOTA}_\alpha \end{aligned}

※ちなみに最初に提示した評価結果の表に存在するAssAはAssAαを閾値αで積分したもの、またAssR（Association Recall）はAssAと同じ考え方で定義されたRecall、つまり AssR_ \alpha = \frac{\textrm{1}}{\textrm{|TP}_ \alpha\textrm{|}} \sum_{c \in \textrm{TP}_ \alpha} \frac{ \textrm{|TPA}_ \alpha \textrm{(c)|} }{ \textrm{|TPA}_ \alpha\textrm{(c)|} + \textrm{|FNA}_ \alpha\textrm{(c)|} }を閾値αで積分したものです。このようにHOTAでは様々なサブメトリクスを自然に定義可能であり、具体的なユースケースが決まっていれば、それに適した指標で評価をすることもできます。

HOTA“の”評価  

まとめ  

• 「物体の検出」「IDの割り当て」「BBOXの位置特定」に関する精度評価をたった1つに組み込んでいる
• エラーの種類の分離性、単調性、対称性といった評価指標としての望ましい性質を持つ
• サブメトリクスを活用することで、目的に応じた性能評価を行うこともできる

References  

The post 物体追跡の評価指標 first appeared on ALBERT Official Blog.

エンジニアブログの過去の投稿はこちらをご覧ください。

http://tech.albert2005.co.jp/

The post エンジニアブログの過去の投稿はこちらをご覧ください first appeared on ALBERT Official Blog.

みなさまこんにちは。池内です。

Redis 3.0.0 から正式な機能として盛り込まれたRedis Clusterの構築と基本的な動作について紹介します。

※ 期せずして本日 LINEさんの事例 LINEの100億超/日メッセージを支えるRedis・HBaseのスケールアウト・アップ戦略（A-5） #linedevday – Togetterまとめ が話題になっていますが、合計48TBものメモリサイズで運用しているようです。凄いですね。

Redis Cluster とは

• 疑似的なマルチマスタ構成
• 複数ノードでデータをシャーディングできる
• スレーブ構成を採用すれば耐障害性の向上も可能

概ね上記のような内容です。マルチマスタを「疑似的」としているのは、実際にデータが各ノードに伝播しているわけではないからです。Redis Clusterは、あるレコードをどのノードに保存するかを把握しておき、ノード間でリダイレクトすることによって、どのノードから接続しても指定するデータにたどり着けるというアーキテクチャを採用しています。この記事では便宜上マルチマスタと表記します。

Redis Cluster マスタのみの構築

下記のノードが存在するとします。（単一のサーバーホストにポート違いで複数台Redisを起動する方法がよく紹介されますが、今回の手順では、実際にサーバーが複数台存在する環境を想定しています）

通常の手順で各ホストにRedisをインストールした後、redis.conf に下記の設定を記述します。

redis.conf の設定

port 16379
cluster-enabled yes
cluster-config-file /etc/redis/nodes.conf
cluster-node-timeout 5000
appendonly yes

設定ファイルの場所や使用するPort番号は適時読み替えて下さい。

Cluster の作成

redis-3.0.0.tar.gz を解凍すると、クラスタ構築用のRubyスクリプト redis-trib.rb が入っているのでこれを利用します。

$ /usr/local/src/redis-3.0.0/src/redis-trib.rb create 192.168.10.212:16379 192.168.10.213:16379 192.168.10.214:16379 192.168.10.215:16379

以上が正常に実行されれば、Cluster の作成は完了です。ログイン時は下記の通りオプションを付与します。

$ redis-cli -c -p 16379

この構成では、4ノード全てがマスタになっています。マルチマスタが実現されているので、どのノードから SET しても、全ノードからGETすることができます。

実際にコマンドを実行すると、下記のように表示されることがあります。

192.168.10.212:16379> set key1 value1
-> Redirected to slot [9189] located at 192.168.10.213:16379
OK

redis1 から接続しましたが、redis2にリダイレクトされ、結果 Key: key1, Value: value1 のレコードは redis2 に保存されます。

この点の解説は多く存在するのでここまでにします。

Redis Cluster マスタ・スレーブの構築

上述の手順では、4つのノード全てがマスタの役割を持っていました。この場合、データが冗長化して保存されている訳ではありません。従ってノードがクラッシュすると、そのノードのデータがロストする可能性があります。また、各ノードの死活監視はRedis Cluster自身が行っていますが、ノードが fail と判定されると、そのままでは「 (error) CLUSTERDOWN The cluster is down」となり、読み書きが出来なくなります。

そこで、Redis Clusterの可用性をあげるためにマスタ・スレーブ構成で構築します。

$ /usr/local/src/redis-3.0.0/src/redis-trib.rb create --replicas 1 192.168.10.212:16379 192.168.10.213:16379 192.168.10.214:16379 192.168.10.215:16379

同様に、 redis-trrib.rv スクリプトで create を行います。このとき、 –replicas 1 オプションを付与します。しかし、下記のエラーが発生します。

*** ERROR: Invalid configuration for cluster creation.
*** Redis Cluster requires at least 3 master nodes.
*** This is not possible with 4 nodes and 1 replicas per node.
*** At least 6 nodes are required.

Redisクラスタはマスタが最低3ノード必要で、各マスタに1つのスレーブが対応付くため、結果的に6ノードが必要になります。そこで、サーバーを2台追加します。このとき設定ファイルは変更する必要がありません。

Cluster の作成

$ /usr/local/src/redis-3.0.0/src/redis-trib.rb create --replicas 1 192.168.10.212:16379 192.168.10.213:16379 192.168.10.214:16379 192.168.10.215:16379 192.168.10.216:16379 192.168.10.217:16379

この結果、以下の状態になったとします。

障害時の挙動

ノードの障害時は、以下のような挙動をとります。

• redis6 がダウンした場合、redis6はSlaveであるため、そのままClusterの動作を続行します。その後 redis6 が復帰した場合、自動でClusterに加えられます。
• redis3 がダウンした場合、redis3 のスレーブである redis6 がマスタに昇格します。redis3 が復帰した場合、今度は redis3 が redis 6のスレーブとしてClusterに参加します。
• redis1 がダウンした場合、redis1 のスレーブである redis4 がマスタに昇格します。続いて redis4がダウンした場合、 (error) CLUSTERDOWN The cluster is down となり動作を続行できません。その後 redis1 または redis4が復帰した場合、マスタとしてClusterに参加します。

全体で6ノード稼働している場合、2ノードの同時停止でCluster全体が機能不全に陥る可能性があります（反対に最大で、3ノードの同時停止まで耐えられます）。AWSで構築する場合、マスタとスレーブのAZを分けるなどの設計が求められます。

なお、各マスタに紐尽くスレーブは1ノードよりも多くすることもできます。

利用ノードの固定

ノードの固定について紹介します。

Redis Clusterでは、レコードが各ノードに散らばって保存されます。しかし、SET型で集合演算を行う際に、集合演算対象のレコードが同一のノードに存在している必要があるという制約が存在します。このときに利用するのが Keys hash tags です。

SET foo-var0001 vlaue
SET foo-var0002 vlaue

どちらかのSETで、リダイレクトが発生する状況であると仮定します。その際、共通利用できるキーの文字列部分を {} で囲うことで、ハッシュとして利用できます。

set {foo}-var0001 vlaue
set {foo}-var0002 vlaue

この結果、{foo}-var0001 と {foo}-var0002 を同一ノードに保存するこができます。

MSET などの Multiple Keys についての注意

Redis Clusterでは、MSETなどの利用にも注意が必要です。

127.0.0.1:16379> MSET key1 value1 key2 value2
(error) CROSSSLOT Keys in request don't hash to the same slot
127.0.0.1:16379> MSET {key}1 value1 {key}2 value2
-> Redirected to slot [12539] located at 192.168.10.214:16379
OK

上記の通り、通常通りMSETを実行するとエラーになります。 hash tags を利用することによってMSETが実行可能になります。MGETも同様です。

クライアントについて

Redis Clusterを利用するには、対応したクライアントライブラリを利用します。RubyやPythonの対応クライアントは公式ドキュメントでも紹介されています。

• antirez/redis-rb-cluster
• Grokzen/redis-py-cluster

いずれも、非対応ライブラリとの差分はインスタンスを作成する際にRedisのノード情報をリストで渡す箇所程度のようです。

まとめ

• マスタノードだけでは可用性の向上には繋がらない点に注意して利用します。
• マスタ・スレーブは可用性の向上に繋がりますが、最小6台構成を取る必要があります。Fail Overの挙動を把握しておく必要があります。
• レコードが同一ノード上にないと問題の発生する処理（コマンド）があります。ノードを固定することもできますが、データの偏りに気を配りましょう。

Redis Sentinelのように司令塔を配置しなくてもよいため、単純な揮発性のデータストアとして利用するにはかなり気軽に運用できそうです。ただし、集合演算をする場合やもう少しシビアな運用を迫られるケースでは、Redis Clusterの特性をよく理解しておく必要があることが分かりました。

参考文献

• Redis Cluster Specification – Redis
• Redis cluster tutorial – Redis

最後になりますが、ALBERTでは、データサイエンティストを積極募集しています。
ぜひ採用ページをご覧ください。

The post Redis Cluster の構築と利用（Redis 3.0.0） first appeared on ALBERT Official Blog.

初めまして、この３月からALBERTにジョインしました最上嗣生と申します。

これまでは理化学研究所脳科学総合研究センターで神経科学、いわゆる「脳研究」をやっていました。特に高等動物の高次視覚野が物体の価値の評価へ寄与をしている様子を調べていました。

さて、そのような研究をしていたものが、ALBERTに加わってからはマーケティング領域の分析をしているわけです。びっくりするほどの違いだと思いますよね？そうです、まずは違いからお話しします。（ほかの方の記事のような実用的な記事は、次回以降にご期待ください。）

研究と今の仕事の一番の違いは仕事のスピードで、これには目を回しました。もちろん人間にできないことをやっているわけはないので、ちゃんと理由があります。研究者にはできないくらい高速で仕事ができる秘密は、「細かいことはいいので結果重視」ということだと思います。研究者の世界では、とにかく細かいことに突っ込まれます。例えばの話ですが、説明変数を３０個選んだとします。２０個に減らしても６０個に増やしてもあまり結果が変わらないことは経験上、そして試してみてわかっています。それでも、学問の世界ではなぜ３０個なのかねちっこく突っ込まれます。答えなければ論文が採択されません。１個刻みで全部調べて最良であることをいい、その理論的な理由もつけたりくらいしないと論文査読者は納得しません。それはやればできますが、倍時間がかかります。しかもあらゆる事柄について同様の突っ込みがなされます。一方、こちらの世界ではそんなことは聞かれなかったことに拍子抜けと驚きを感じました。要するに、役に立つかどうかが問題なのでしょう。

次の違いは、変数がなんだかわからないということです。それが何を意味しているのか、空欄は単なる欠測なのか、それとも何か別の意味なのか。欠測は偶然発生するのか。これまで実験科学者をやっていたときは、変数は自分で作るものでしたから、意味が分からないということはありませんでした。一方、ALBERTに入ってからマーケティングの分析をやってみると、まず変数がなんだかわかりません。お客様に聞いてわかるとも限りません。変数自身から調べたりします。
また、こちらではデータは分析の都合に合わせて作られるわけではないので、是非なくてはならないと思う変数がなかったり、要らない変数がたくさんあったりします。要らないものは捨てればいいですが、要るものがないのは苦しいものです。ほかの変数を組み合わせて推定したりします。
しかし実は、実験の最初の計画でないアドホック解析のために変数が足りないことは（厳密にはよくないことではあるけど）神経科学のような未知の要素の多い科学分野ではよくあることです。だからこそ適応できたといえます。

最後のちがいは心構えです。こちらに来てから、お客様への善意ということを意識するようになりました。特に直接のクライアントよりさらにそのお客様、消費者のことをよく考えます。この仕事の結果、ちょっとにやりとしたり嬉しかったりする人が増えるといいと思います。実験室ではもちろんそんなことは考えるはずもありませんでした。

さて、一方脳研究と、今の仕事とで変わらないことも多くあります。

意外と解析技術は変わりません。簡単なｔ検定から始まって、サポートベクトルマシンやニューラルネットのような機械学習まで解析手法として使うところは同じです。（科学研究は現実を冷静に認識するのが目的ですから、ニューラルネットのような多数の安定状態をもつようなものを私自身は規律として避けていました。複数の安定状態というのはいわば主観のようなものですから。しかし実際は気軽にそういう解析手法を使う人も多かったので、私も馴染んではいました。）

一方、解析技術というだけではなく、行き着く先というのも意外と共通です。
と、いうのは、脳というのは何のためにあるかというと、つまり外界について解析して、その結果から有利な行動を選ぶためにあるわけです。
したがって、脳の働きとは、ほとんど今我々がやっているマーケティングの解析と同じものです。いわば我々の仕事はクライアントの脳になることですから。(決断を代替することはできませんが、視覚野となって市場を「見て」、前頭葉となって仮説を立て、ドーパミン系になって何かをした時の利益を予測するわけです。)
したがって脳についての理論研究というのはほとんど、我々の解析手法の一覧とほぼ同じ構造をしています。神経にインスパイアされたニューラルネットは当然として、ベイジアンの各手法、そしてなによりdeep learningは脳の理論としてよく登場します。（脳の理論として出てこないのはSVMくらいかな。）
私がやっていた実験的な脳研究とは例えると、マーケティングの解析をやっているブラックボックス（例えばアルベルト）を外から見て、突っついて（すなわち実験的に介入して）内部がどんな解析手法を実行しているか推定するというものだったわけです。今度は中身の方になったわけですが、手法と知識は共通です。
だからより進んだ脳の理解の探求と、より進んだ解析手法の探求も同じようなこととなります。

最後に、知識という点での共通もあります。脳研究と心理学研究からもたらされた考えが、今ではマーケティングの分野で必須になっている例があります。たとえば、人は自分の行動の理由を説明できない、無意識や直感で行動がきまるということ、プライミングが無意識に選択に影響を与えること、我々の行動は速く直感的なシステムと遅く意識的なシステムが拮抗する形で支配されていること、反応時間に無意識のバイアスが表れることなどです。これらの知識によりマーケティングは消費者が言葉で語る建前を超えてその心について多少なりとも知ることができるようになりました。

このように多くの知識、方法の共通点があり、マッチする仕事を見つけたと思っています。みなさんもどうですか？いまALBERTでは積極採用中のようです。詳細はこちらをご覧になってください。

The post 神経科学からマーケティングへ…違いと意外な類似 first appeared on ALBERT Official Blog.